使用“from”时没有（Generic（fa））的实例

Question

我遇到了为以下代码找到合适的类型约束的问题

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
import GHC.Generics

data Value = One | Two deriving Generic

class Class a where
    cname :: a -> String -> Bool
    default cname :: (Generic a, GClass (Rep a))
               => a -> String -> Bool
    cname = gname . from

class GClass f where
    gname :: f a -> String -> Bool

instance GClass (f :+: g) where
    gname (L1 x) s | conName (from x) == s = True
                   | otherwise             = False
    gname (R1 x) s | conName (from x) == s = True
                   | otherwise             = False

它失败了

No instance for (Generic (f a)) arising from a use of `from'

像这样将约束添加到gname

instance (Generic (f a)) => GClass (f :+: g) where

失败了

Could not deduce (Generic (f a1)) arising from a use of `from'
from the context (Generic (f a))

编辑：完整代码段的完整错误消息

Generic.hs:19:31:
    No instance for (Generic (f a)) arising from a use of `from'
    Possible fix: add an instance declaration for (Generic (f a))
    In the first argument of `conName', namely `(from x)'
    In the first argument of `(==)', namely `conName (from x)'
    In the expression: conName (from x) == s

Generic.hs:21:31:
    No instance for (Generic (g a)) arising from a use of `from'
    Possible fix: add an instance declaration for (Generic (g a))
    In the first argument of `conName', namely `(from x)'
    In the first argument of `(==)', namely `conName (from x)'
    In the expression: conName (from x) == s

这是GHC 7.6.3

Answer 1

我假设您正在尝试使用Ghc.Generics获取构造函数名称。 构造函数，字段和数据类型元数据保存在M1节点中。 M1节点标记有D ， C或S以指示它们是否包含数据类型，构造函数或选择器（字段）元数据。

我简化了你的Class和GClass以返回最外层的构造函数名称，而不是检查它是否是某个名称。 我正在将Class解释为类型的类，其值具有带有名称的最外层构造函数。

{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
import GHC.Generics

data Value = One | Two deriving Generic

class Class a where
    cname :: a -> String
    default cname :: (Generic a, GClass (Rep a))
               => a -> String
    cname = gname . from

class GClass f where
    gname :: f a -> String

我们希望能够为Value派生一个Class实例并观察cname One == "One"和cname Two == "Two" 。

instance Class Value    

main = do
    print . cname $ One
    print . cname $ Two

我们需要为三个表示节点实现GClass才能执行此操作。 One的代表是：

> from One
M1 {unM1 = L1 (M1 {unM1 = U1})}

外部M1是M1 D ，它在字典中保存Value数据类型的元数据。 L1正在选择第一个构造函数One 。 内部M1是M1 C ，在字典中保存One构造函数的元数据。 我们并不关心比它更深的东西，因为M1代表最外层的构造函数。

最有趣的节点是内部M1 C ，它保存构造函数元数据。 只要元数据实现了Constructor类，我们就可以获得构造函数名称。 Constructor类包含conName ，它在给定适当代理的情况下返回构造函数名称，并且相应的代理类型设计为看起来像M1 C的类型。

conName :: Constructor c => t    c (f :: * -> *) a -> [Char]
                            M1 C c  f            p

这意味着只要有元数据标记c的Constructor实例，我们就可以简单地为M1 C节点实现GClass

instance (Constructor c) => GClass (M1 C c f) where
    gname = conName

当我们面对两个构造函数之间的选择时， :+: ：，如果我们可以确定两个构造函数的最外层构造函数名称，我们可以确定最外面的构造函数名称。

instance (GClass f, GClass g) => GClass (f :+: g) where
    gname (L1 x) = gname x
    gname (R1 x) = gname x

当我们处理数据类型M1 D的元数据节点时，我们可以在确定没有元数据节点的表示的最外层构造函数名称时确定最外层的构造函数名称。

instance GClass f => GClass (M1 D c f) where
    gname (M1 x) = gname x

通过这三个实例，我们可以运行我们想要的代码并查看它

> cname One
"One"
> cname Two
"Two"