具有约束参数函数的类型类

Question

我想写一个这样的类：

class C c where
op :: c -> c -> Bool
class A b => B b where
func :: C c => b -> c -- ^ type 'c' is random(forall). 
func2 :: b -> b -> Bool
func2 x y = func b `op` func c

在这里，c是受C限制的类型，此限制将在 func2 中使用。 但这不能是编译器。类型c不是真正的类型。我尝试添加forall或使用TypeFamilies，但他们都无法做到这一点。TypeFamilies看起来不错，但它不能在功能定义中限制使用，例如C c => b -> c或'类型 X x ：： C * => *。

我必须使用(A b, C c) => B b c来定义此类吗？我有另一个类使用 B 像B b => D d b.如果为 B 类添加一个参数，则 D 类还需要一个参数。实际上，Seq a将与类D一起使用，无法匹配D d b。

编辑：还有一个描述。

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
module Main where
type Ta = (Integer, Integer)
newtype Tb t = Tb { tb :: [t] } deriving Show
class Eq a => A a where
a1f :: Ord b => a -> b
a2f :: a -> a -> Bool
a2f x y = a1f x >= a1f y
instance A Ta where
a1f (_, y) = y
class A a => B b a where
op :: b a -> b a
instance B Tb Ta where
op x = x
main :: IO ()
main = putStrLn $ show $ op $ (Tb [(1, 1)] :: Tb Ta)

编译器会抱怨a2f :: b -> Bool行：

• Could not deduce (Ord a0) arising from a use of ‘>=’
from the context: A a
bound by the class declaration for ‘A’ at test.hs:10:15
The type variable ‘a0’ is ambiguous
These potential instances exist:
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Ord Integer
-- Defined in ‘integer-gmp-1.0.2.0:GHC.Integer.Type’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
...plus 22 others
...plus four instances involving out-of-scope types
(use -fprint-potential-instances to see them all)
• In the expression: a1f x >= a1f y
In an equation for ‘a2f’: a2f x y = a1f x >= a1f y

编辑 2：使用类型族

...
class Eq a => A a where
type AT a :: *
a1f :: Ord (AT a) => a -> AT a
a2f :: a -> a -> Bool
a2f x y = a1f x >= a2f y
instance A Ta where
type AT Ta = Integer
a1f (_, y) = y
...

它将显示错误：

• Could not deduce (Ord (AT a)) arising from a use of ‘>=’
from the context: A a
bound by the class declaration for ‘A’ at test.hs:10:15
• In the expression: a1f x >= a1f y
In an equation for ‘a2f’: a2f x y = a1f x >= a1f y

Answer 1

允许它编译的类型族代码的最小修复是将对Ord约束的需求从生产位置移动到使用位置：

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ConstrainedClassMethods #-}
type Ta = (Integer, Integer)
class Eq a => A a where
type AT a :: *
a1f :: a -> AT a
a2f :: Ord (AT a) => a -> a -> Bool
a2f x y = a1f x >= a1f y
instance A Ta where
type AT Ta = Integer
a1f (_, y) = y

如果您只想在使用默认实现时要求Ord (AT a)，您可以使用DefaultSignatures(并消除ConstrainedClassMethods(：

{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DefaultSignatures #-}
type Ta = (Integer, Integer)
class Eq a => A a where
type AT a :: *
a1f :: a -> AT a
a2f :: a -> a -> Bool
default a2f :: Ord (AT a) => a -> a -> Bool
a2f x y = a1f x >= a1f y
instance A Ta where
type AT Ta = Integer
a1f (_, y) = y

但是，这种类型类结构过于奇怪和不合时宜。(当我阅读它时，它引发了一些危险信号：Eq约束在那里做什么？为什么有一个只有一个实例的类？为什么a2f在课堂内而不是课外？为什么a1f不是一个非类多态函数？为什么我们应该相信每种类型只有一个规范选择函数？

我想重申的是，您应该告诉我们更多关于您试图实现的目标，而不是谈论您为实现该目标而提出的类型类。关于这种架构的很多事情都尖叫着"初学者试图像OO语言使用类一样使用类型类"，这将成为阻抗不匹配和剪纸的持续来源。我强烈怀疑你根本不应该定义一个新的类型类。

Answer 2

在你的代码中，问题只是func b `op` func c中的c是不明确的。这不是什么大问题：只需用本地签名确定选择即可。例如

func2 x y = func x `op` (func y :: Int)

但这可能不是你真正想要的。c真的应该是func类的类型参数，还是整个实例的类型参数？在后一种情况下，MPTC将是正确的方法。

{-# LANGUAGE MultiParamTypeClasses, AllowAmbiguousTypes, TypeApplications #-}
class ∀ b c . (A b, C c) => B b c where
func :: b -> c
func2 :: b -> b -> Bool
func2 x y = func @b @c b `op` func c

或者，如果对于每个实例，只有一个c有意义，那么您需要一个类型家庭或基金。

{-# LANGUAGE TypeFamilies #-}
class A b => B b where
type Ct b :: *
func :: b -> Ct b
func2 :: b -> b -> Bool
func2 x y = func b `op` func c