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

我们希望能够为Class派生Value个实例并观察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

这意味着我们只需为GClass个节点实施M1 C，只要元数据标记为Constructor实例c

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"

（Generic（f a））没有使用'from＆＃39;

1 个答案: