Haskell 约束族

Question

我开始接触 GHC 7.4.2 中新的类约束扩展，但在让一个小示例工作时遇到一些问题。代码如下:

{-# LANGUAGE UndecidableInstances,
         MultiParamTypeClasses,
         KindSignatures,
         TypeFamilies,
         Rank2Types,
         ConstraintKinds,
         FlexibleInstances,
         OverlappingInstances #-}

module Test where

  import GHC.Exts  -- to get Constraint type constructor

  class NextClass f where
    type Ctxt f a :: Constraint
    next :: (Ctxt f a) => a -> a

  instance NextClass Int where
    type Ctxt Int a = Num a
    next b = b + 1

  n :: (NextClass a) => a -> a
  n v = next v

我想要做的是定义一个 NextClass 类型类，它允许我(给定值 x)获取作为 实例的所有类型的 x 的下一个值下一个类。要使用 + 运算符，我需要 Int 的 Num a 类约束。

但是，GHC 给了我以下错误:

Could not deduce (Ctxt f0 a) arising from a use of `next'
from the context (NextClass a)
   bound by the type signature for n :: NextClass a => a -> a
In the expression: next v
In an equation for `n': n v = next v

我怀疑 GHC 告诉我它没有足够的信息来确定要使用哪个约束系列实例。

有人可以解释一下我在这里做错了什么吗？这是约束族的正确使用吗？

TIA

Answer 1

您的定义中发生了一些奇怪的事情。首先，类变量 f 在(唯一的)类方法 next 的类型中从未被提及。编译器应该如何选择要使用的类型类的实例？我假设你的意思是这样的:

{-# LANGUAGE ConstraintKinds, TypeFamilies #-}
module Test where

import GHC.Exts  -- to get Constraint type constructor

class NextClass f where
    type Ctxt f :: Constraint
    next :: Ctxt f => f -> f

instance NextClass Int where
    type Ctxt Int = Num Int
    next b = b + 1

n :: (NextClass a) => a -> a
n v = next v

下一个奇怪的地方是 Int 已经有一个 Num 实例，所以这并不是一个太大的限制。但我们现在先把它放在一边(因为它不会影响我们得到的错误)，只看新的错误:

test.hs:15:7:
    Could not deduce (Ctxt a) arising from a use of `next'
    from the context (NextClass a)
      bound by the type signature for n :: NextClass a => a -> a
      at test.hs:15:1-12
    In the expression: next v
    In an equation for `n': n v = next v

实际上，这个错误看起来很合理:约束的重点是拥有 NextClass a 的实例是不够的；我们还必须有一个 Ctxt a 的实例。所以我们可以修复类型签名:

n :: (NextClass a, Ctxt a) => a -> a
n v = next v

...然后编译。最后一个奇怪的地方是，这是约束类型的一种特别退化的使用，因为这个更简单的代码本质上是等效的:

class NextClass f where
    next :: f -> f

instance Num Int => NextClass Int where
    next b = b + 1

...从前一个事物到新事物的转换非常机械:而不是声明 instance NextClass {- foo -} where type Ctxt {- foo -} = {- bar -}，您只需编写 instance {- bar -} => NextClass {- foo -} 即可。