在Haskell中创建许多类似的NewTypes/TypeClass实例

Question

我是Haskell的初学者，正在尝试学习类型类和类型。我有以下示例（它代表了我正在研究的代数中的一个实际问题），其中我定义了一个仅包装Num实例的类型，以及一个定义二进制操作baz的typeclass。

newtype Foo i = B i deriving (Eq, Ord, Show)

class Bar k where
    baz :: k -> k -> k

instance Num k => Bar (Foo k) where
    baz (B a) (B b) = B (f a b)

f :: Num a => a -> a -> a
f a b = a + b

当将bar定义为此实例时，我意识到我希望能够使用类型“改变”函数f。需要说明的是：我想提供一个函数f::numa=>a->a->a，并返回一个新的类型foo，它是bar的一个实例。假设我想这样做5次、10次，唯一的区别是不同的函数f。上面的代码我当然可以复制粘贴，但是我想知道有没有别的办法呢？

在我看来，我把事情弄糊涂了。在哈斯克尔做这样的事情最好的方法是什么？这是一个好的设计选择吗？我认为什么是对的/错的？为什么？

编辑：我意识到一个具体的示例可能有助于使问题更清楚（注意它可能看起来很复杂，我无法比这更简化代码。上面的问题包含了我认为相同的信息）：我感兴趣的类型类是来自HaskellforMaths库的algebra k v:

class Algebra k b where
    unit :: k -> Vect k b
    mult :: Vect k (Tensor b b) -> Vect k b

newtype Basis i = T i deriving (Eq, Ord, Show)

type Expression k = Vect k (Basis Int)

instance Algebra k Basis where
    unit x = x *> return I
    mult = linear mult'
           where mult' (T x ,T y) = comm x y
           where comm a b = sum $ map (\c -> structure a b c *> t c) [0..n]

t :: Int -> Expression k
t a = return (T a)

Answer 1

你可以用反射。这是一个相当先进的技术，可能有更好的方法来解决你的问题，但你说的方式似乎这就是你要找的。

{-# LANGUAGE FlexibleContexts, RankNTypes, ScopedTypeVariables, UndecidableInstances #-}

import Data.Reflection
import Data.Proxy

class Bar k where
    baz :: k -> k -> k

newtype Foo f i = B i       -- f is a type level representation of your function
   deriving (Eq, Ord, Show)

instance (Num k, Reifies f (k -> k -> k)) => Bar (Foo f k) where
    baz (B a) (B b) = B (reflect (Proxy :: Proxy f) a b)

mkFoo :: forall i r. (i -> i -> i) -> i
      -> (forall f. Reifies f (i -> i -> i) => Foo f i -> r) -> r
mkFoo f x c = reify f (\(p :: Proxy f) -> c (B x :: Foo f i))

main = do
    mkFoo (+) 5 $ \foo1 -> do
    print $ foo1 `baz` B 5  -- 10

    mkFoo (*) 5 $ \foo2 -> do
    print $ foo2 `baz` B 5  -- 25

    print $ foo1 `baz` foo2 -- type error

这里有很多事情，所以请注意。

Reifies f (k -> k -> k)

是一个约束，它意味着f是k->k->k类型函数的类型级表示形式。当我们reflect(Proxy::proxyf)（将类型f传递给reflect的一种很好的方式，因为直到最近才允许显式类型应用程序）时，我们会将函数本身收回。

mkFoo :: forall i r. (i -> i -> i) -> i
      -> (forall f. Reifies f (i -> i -> i) => Foo f i -> r) -> r

(forall f. Reifies f (i -> i -> i) => Foo f i -> r) -> r

exists f. ( Reifies f (i -> i -> i) , Foo f i )

mkFoo (+) 5 $ \foo -> -- what to do with foo

在函数中，foo的行为就像它具有类型foo f0 integer，其中f0是专门为该函数创建的全新类型。

它不允许我们从不同的fbaz一起foo，这是非常好的，但不幸的是，它不够聪明，不允许我们使用对mkfoo的不同调用，用同一个函数一起baz一起foo，因此：

mkFoo (+) 5 $ \foo1 -> mkFoo (+) 5 $ \foo2 -> foo1 `baz` foo2  -- type error