haskell – 类型族可以做什么,多param类型类和函数依赖不能

类型之间的“开放”关系,例如转换函数,使用TypeFamilies似乎不可能.使用MultiParamTypeClasses完成：

class Convert a b where
    convert :: a -> b

instance Convert Foo Bar where
    convert = foo2Bar

instance Convert Foo Baz where
    convert = foo2Baz

instance Convert Bar Baz where
    convert = bar2Baz

类型之间的表观关系,例如一种类型安全的伪鸭类型机制,通常用标准类型族来完成.使用MultiParamTypeClasses和FunctionalDependencies完成：

class HasLength a b | a -> b where
    getLength :: a -> b

instance HasLength [a] Int where
    getLength = length

instance HasLength (Set a) Int where
    getLength = S.size

instance HasLength Event DateDiff where
    getLength = dateDiff (start event) (end event)

类型之间的双射关系,例如对于未装箱的容器,可以通过具有数据族的TypeFamilies来完成,但是您必须为每个包含的类型声明新的数据类型,例如使用newtype.无论是那个还是一个内射类型的家族,我认为在GHC 8之前是不可用的.使用MultiParamTypeClasses和FunctionalDependencies完成：

class Unboxed a b | a -> b,b -> a where
    toList :: a -> [b]
    fromList :: [b] -> a

instance Unboxed FooVector Foo where
    toList = fooVector2List
    fromList = list2FooVector

instance Unboxed BarVector Bar where
    toList = barVector2List
    fromList = list2BarVector

最后是两种类型和第三种类型之间的主观关系,例如python2或java样式除法函数,它们也可以通过使用MultiParamTypeClasses与TypeFamilies完成.使用MultiParamTypeClasses和FunctionalDependencies完成：

class Divide a b c | a b -> c where                                                                  
    divide :: a -> b -> c                                                                            

instance Divide Int Int Int where                                                                    
    divide = div

instance Divide Int Double Double where                                                              
    divide = (/) . fromIntegral                                                                      

instance Divide Double Int Double where                                                              
    divide = (. fromIntegral) . (/)                                                                  

instance Divide Double Double Double where                                                           
    divide = (/)

我还应该补充的另一件事是,似乎FunctionalDependencies和MultiParamTypeClasses也更简洁(无论如何都是上面的例子),因为你只需要编写一次类型,而你不必提出一个虚拟类型名称,然后您必须为每个实例键入,就像使用TypeFamilies一样：

instance FooBar LongTypeName LongerTypeName where
    FooBarResult LongTypeName LongerTypeName = LongestTypeName
    fooBar = someFunction

VS：

instance FooBar LongTypeName LongerTypeName LongestTypeName where
    fooBar = someFunction

因此,除非我确信,否则我真的应该不打扰TypeFamilies并仅使用FunctionalDependencies和MultiParamTypeClasses.因为据我所知,它将使我的代码更简洁,更一致(更少关注的扩展),并且还会给我更多的灵活性,例如开放式关系或双向关系(可能后者是GHC的解决方案) 8).