约束约束的参数

Question

我有一个第一个类型类，它接受 leaf 的列表列表列表：

{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-}
class ListTree leaf t where
  lmap :: (leaf -> leaf) -> t -> t
instance ListTree leaf leaf where lmap f v = f v
instance ListTree leaf t => ListTree leaf [t] where lmap f v = map (lmap f) v

我有第二个类型类，它接受 a 的 2 元组和 3 元组：

class Tups a t where
  tmap :: (a -> a) -> t -> t
instance Tups a (a,a) where tmap f (x,y) = (f x, f y)
instance Tups a (a,a,a) where tmap f (x,y,z) = (f x, f y, f z)

我想将它们结合起来描述以一些leaf 类型的 2 或 3 元组结尾的嵌套列表：

class LTTree leaf t where
  ltmap :: (a -> a) -> t -> t
instance (Tups leaf x, ListTree x t) => LTTree leaf t where ltmap f v = lmap (tmap f) v

但是，最后一段代码给了我几个错误：

Could not deduce (LTTree leaf0 t)
  from the context: LTTree leaf t

In the ambiguity check for ‘ltmap’
  To defer the ambiguity check to use sites, enable AllowAmbiguousTypes

Could not deduce (Tups leaf x0)
  from the context: (Tups leaf x, ListTree x t)

In the ambiguity check for an instance declaration
  To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
  In the instance declaration for ‘LTTree leaf t’

如果我添加AllowAmbiguousTypes，我仍然会收到类似的错误。

不过，我可以通过内联其他两个类型类的代码来很好地定义 LTTree 类：

class LTTree leaf t where
  ltmap :: (leaf -> leaf) -> t -> t
instance LTTree leaf (leaf,leaf) where ltmap f (x,y) = (f x, f y)
instance LTTree leaf (leaf,leaf,leaf) where ltmap f (x,y,z) = (f x, f y, f z)
instance LTTree leaf t => LTTree leaf [t] where ltmap f v = map (ltmap f)

如何将ListTree leaf t 类与Tups a t 类结合起来，以便列表树的叶子是a 的2 或3 元组？我不知道如果有帮助，请考虑添加额外的 GHC 扩展。

如果重要的话，我真正的用例是对列表树建模，其中叶子是行多态记录（使用 CTRex），其中记录中的每个字段都是某个类型类的实例（例如 Show，要打印树）。

Answer 1

你还有一个问题。你的ListTree 课程没用！

> lmap id [5 :: Integer]
error: blah blah
> lmap id (5 :: Integer)
error: blah blah
> lmap (+2) [[5::Integer], [], [2,3]]
error: blah blah

先添加一些黑魔法来解决这个问题：

{-# LANGUAGE FunctionalDependencies, GADTs #-}
class ListTree leaf tree where lmap :: (leaf -> leaf) -> (tree -> tree)
instance {-# OVERLAPPABLE #-} (leaf ~ tree) => ListTree leaf tree where -- 1
  lmap = id
instance ListTree leaf tree => ListTree leaf [tree] where -- 2
  lmap = map . lmap

（(a ~ b) 是一个等式约束；当a 和b 是同一类型时它成立。它需要使用GADTs 或TypeFamilies。）

根据the rules of instance resolution，在检查lmap id [5 :: Integer]时，GHC会遇到这两个实例，发现它们都可以被实例化：1和leaf = [Integer]和tree = [Integer]，2和leaf = Integer和@ 987654336@。要选择一个，它检查2 的实例化是否对1 有效。即：leaf = Integer、tree = [Integer] 是 1 的有效实例化吗？答案是肯定的，因为直到稍后才会检查具有等式约束的上下文。然后，它检查OVERLAPPABLE/OVERLAPPING/OVERLAPS pragmas。如果周围有更好的实例，OVERLAPPABLE 实例将被丢弃。在这种情况下，1 被丢弃，只剩下2。它被使用了，所以lmap id [5 :: Integer] == [5]。其他示例也可以。

在LTTree，你有一个错字。应该是：

class LTTree leaf tree where ltmap :: (leaf -> leaf) -> tree -> tree

使用leaf，而不是a。您还有另一个问题：推理器非常生气，因为您让它完成所有这些工作：

> instance (Tups leaf x, ListTree x t) => LTTree leaf t where ltmap f v = lmap (tmap f) v
error: blah blah

启用ScopedTypeVariables 和TypeApplications 来帮助它：

{-# LANGUAGE ScopedTypeVariables, TypeApplications #-}
instance (Tups leaf x, ListTree x t) => LTTree leaf t where ltmap f v = lmap @x @t (tmap @leaf @x f) v

（或者只是用:: 明确地给出类型，但这很痛苦）

但更好的想法是启用FunctionalDependencies 并开始喷洒它们，因为它们代表了类型级计算的理念：类型类的参数的某些子集可以唯一地确定其他参数。这将产生最终版本：

{-# LANGUAGE FlexibleInstances
           , FunctionalDependencies
           , GADTs
           , UndecidableInstances #-}
class ListTree leaf tree | tree -> leaf where lmap :: (leaf -> leaf) -> tree -> tree
instance {-# OVERLAPPABLE #-} (leaf ~ tree) => ListTree leaf tree where lmap = id
instance ListTree leaf tree => ListTree leaf [tree] where lmap = map . lmap
-- The tree determines the leaf

class Tups leaf tree | tree -> leaf where tmap :: (leaf -> leaf) -> tree -> tree
-- Change instances to help type inference along:
instance (a ~ b) => Tups a (a, b) where tmap f (x, y) = (f x, f y)
instance (a ~ b, b ~ c) => Tups a (a, b, c) where tmap f (x, y, z) = (f x, f y, f z)
-- tmap (+2) (5 :: Integer, 3, 2) now works because the type info from 5 spreads out
-- via the equality constraints

class LTTree leaf tree | tree -> leaf where ltmap :: (leaf -> leaf) -> tree -> tree
instance (Tups leaf mid, ListTree mid tree) => LTTree leaf tree where ltmap = lmap . tmap
-- mid can be deduced from tree via ListTree's fundep
-- leaf can be deduced from mid via Tups' fundep
-- leaf can be deduced from tree

它有效！

> ltmap (+(2 :: Integer)) [[[(5, 2)]], [], [[(2, 8), (4, 5)]]]
[[[(7,4)]],[],[[(4,10),(6,7)]]]