Question

我正在尝试编写一些Haskell代码，其中有多种数据类型，每种类型都可以有多个实现。为此，我将每个数据类型定义为class，其方法是相关的构造函数和选择器，然后根据给定的构造函数和选择器对该类的成员实现所有操作。

例如，也许A是一个多项式类（包含方法getCoefficients和makePolynomial），可以表示为SparsePoly或DensePoly B是一个复数类（包含方法getReal，getImag和makeComplex），可以表示为ComplexCartesian或ComplexPolar

我在下面复制了一个最小的例子。我有两个类A和B，每个类都有一个实现。我想自动将这两个类的所有实例都放入Num的实例中（这需要FlexibleInstances和UndecidableInstances类型扩展名）。当我只有A或B之一时，这很好用，但是当我尝试用两者编译时，我收到以下错误：

Duplicate instance declarations:
  instance [overlap ok] (A a, Num x, Show (a x), Eq (a x)) =>
                        Num (a x)
    -- Defined at test.hs:13:10-56
  instance [overlap ok] (B b, Num x, Show (b x), Eq (b x)) =>
                        Num (b x)
    -- Defined at test.hs:27:10-56

我认为'重复实例声明'消息是因为数据类型可以成为A和B的实例。我希望能够向编译器做出我不会这样做的承诺，或者可能指定在类型是两个类的实例的情况下使用的默认类。

有没有办法做到这一点（也许是另一种类型的扩展？）或者这是我坚持的事情？

这是我的代码：

{-# LANGUAGE FlexibleInstances, UndecidableInstances, OverlappingInstances #-}

class A a where
    fa :: a x -> x
    ga :: x -> a x

data AImpl x = AImpl x deriving (Eq,Show)

instance A AImpl where
    fa (AImpl x) = x
    ga x = AImpl x

instance (A a, Num x, Show (a x), Eq (a x)) => Num (a x) where
    a1 + a2 = ga (fa a1 + fa a2)
    -- other implementations go here


class B b where
    fb :: b x -> x
    gb :: x -> b x

data BImpl x = BImpl x deriving (Eq,Show)

instance B BImpl where
    fb (BImpl x) = x
    gb x = BImpl x

instance (B b, Num x, Show (b x), Eq (b x)) => Num (b x) where
    -- implementations go here

编辑为了让自己清楚，我不是想用这种技术编写任何实用的代码。我这样做是为了帮助自己更好地理解类型系统和扩展。

Answer 1

这部分问题

我认为'重复实例声明'消息是因为数据类型可以成为A和B的实例。我希望能够向编译器做出我不会这样做的承诺，或者可能指定在类型是两个类的实例的情况下使用的默认类。

不正确。这实际上是因为你写了两个实例，

instance Num (a x)
instance Num (b x)

编译器无法区分（请参阅@ hammar注释中的链接，类上下文不计算用于区分实例声明的目的）。

一种解决方案是添加见证类型。

{-# LANGUAGE FlexibleInstances, FlexibleContexts, UndecidableInstances, OverlappingInstances #-}

data AWitness

data AImpl witness x = AImpl x deriving (Eq,Show)

instance A (AImpl AWitness) where
    fa (AImpl x) = x
    ga x = AImpl x

instance (A (a AWitness), Num x, Show (a AWitness x), Eq (a AWitness x)) => Num (a AWitness x) where
    a1 + a2 = ga (fa a1 + fa a2)

编译器可以使用见证类型来区分您的实例声明。

Answer 2

没有什么好方法可以做到这一点;最佳做法是定义一些常量，如

plusA, minusA :: (A a, Num x) => a x -> a x -> a x

这使得Num实例在A实例后更具机械性：

instance A Foo where ...
instance Num x => Num (Foo x) where
    (+) = plusA
    (-) = minusA

有趣的类型！解决多个实例声明

2 个答案: