Question

问题：

最近我在这里询问了以下问题，询问如何为任意多态ADT（代数数据类型）创建一个通用映射函数和Functor的通用实例，如Lists，Trees等：< / p>

Functor instance for generic polymorphic ADTs in Haskell?

现在，我正在尝试重新制定上述内容以与recursion-schemes兼容。即，不是定义基础仿函数，而是将类型定义为其固定点，我想一方面定义类型，另一方面定义基本仿函数，并使用Base族类型关联它们。 / p>

所以不要这样做：

data ListF a b = NilF | ConsF a b
newtype Fix f = Fix { unFix :: f (Fix f) }
type List a = Fix (ListF a)

我想这样做：

data ListF a b = NilF | ConsF a b
data List a = Nil | Cons a (List a)
type instance Base (List a) = ListF a

这样我可以利用recursion-schemes库的强大功能，同时仍然能够为这些多态类型定义通用fmap。不仅如此，如果能够使用“普通”类型而不是修复点的类型同义词，这是一种更愉快的体验。

尝试：

最初我考虑过一方面有一个Bifunctor实例，并以某种方式强制或使其等于相应的Base系列实例。目前我只能考虑使用a :~: b中的Data.Type.Equality。这是我到目前为止所得到的：

{-# LANGUAGE TypeOperators, Rank2Types #-}
import Data.Bifunctor
import Data.Functor.Foldable
import Data.Type.Equality

gmap :: (Bifunctor p, Foldable (f a), Unfoldable (f b)) => 
        (forall x. p x :~: Base (f x)) -> (a -> b) -> f a -> f b
gmap refl f = cata alg
    where
        alg = embed . 
              castWith (apply refl Refl) . 
              bimap f id . 
              castWith (apply (sym refl) Refl)

我的问题在于尝试定义Functor的实例。我不知道在定义实例时如何指定那些特定的类型约束。我正在考虑以某种方式创建类型类Equals，并做这样的事情：

instance (Bifunctor p, Foldable (f a), Unfoldable (f b), Equals (p a) (Base (f a))) 
    => Functor f where

但是我不知道这是否可行，也不知道我是否以正确的方式接近它（例如我不确定我的gmap的定义是否正确）。

供参考，这是原始SO问题中通用gmap的定义：

gmap :: (Bifunctor f) => (a -> b) -> Fix (f a) -> Fix (f b)
gmap f = unwrapFixBifunctor . cata alg . wrapFixBifunctor
  where
    alg = Fix . bimap f id

    unwrapFixBifunctor :: (Bifunctor f) => Fix (WrappedBifunctor f a) -> Fix (f a)
    unwrapFixBifunctor = Fix . unwrapBifunctor . fmap unwrapFixBifunctor . unFix

    wrapFixBifunctor :: (Bifunctor f) => Fix (f a) -> Fix (WrappedBifunctor f a)
    wrapFixBifunctor = Fix . fmap wrapFixBifunctor . WrapBifunctor . unFix

更新

有人指出，gmap的以下定义会更为一般，不需要任何类型级别相等的奇怪应用：

gmap :: (Foldable t, Unfoldable d, Bifunctor p, Base d ~ p b, Base t ~ p a)
        => (a -> b) -> t -> d
gmap f = cata ( embed . bimap f id )

但是，我仍然找不到创建具有类似类型约束的Functor实例的方法

Answer 1

With a little help from @kosmikus，只要您对UndecidableInstances感到满意，我就能够合并一个有效的版本。

我们的想法是从a的上下文中移除对b和gmap的所有引用，要求forall x. Foldable (f x)等等，使用{{3}进行编码} package：

{-# LANGUAGE TypeFamilies, ScopedTypeVariables, TypeOperators, ConstraintKinds #-}
{-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, FlexibleContexts #-}
import Data.Bifunctor
import Data.Functor.Foldable
import Data.Constraint
import Data.Constraint.Forall

-- https://stackoverflow.com/a/28067872/477476
class (p x ~ Base (f x)) => Based p f x
instance (p x ~ Base (f x)) => Based p f x

gmap :: forall p f a b. ( Bifunctor p 
                        , ForallF Foldable f
                        , ForallF Unfoldable f
                        , Forall (Based p f))
     => (a -> b) -> f a -> f b
gmap f = case (instF :: ForallF Foldable f :- Foldable (f a)) of
  Sub Dict -> case (instF :: ForallF Unfoldable f :- Unfoldable (f b)) of
    Sub Dict -> case (inst :: Forall (Based p f) :- Based p f a) of
      Sub Dict -> case (inst :: Forall (Based p f) :- Based p f b) of
        Sub Dict -> cata (embed . bimap f id)

在a和b退出的情况下，我们可以将gmap变为fmap：

{-# LANGUAGE UndecidableInstances #-}
instance (Bifunctor p, ForallF Foldable f, ForallF Unfoldable f, Forall (Based p f)) => Functor f where
    fmap = gmap

编辑添加：上述实例的问题在于它会匹配任何类型的正确类型，如@gonzaw所述：如果你有

data ListT a = NilT
             | ConsT a (ListT a)

data ListF a b = NilF
               | ConsF a b

type instance Base (ListT a) = ListF a

instance Bifunctor ListF where ...
instance Functor (ListF a) where ...
instance Foldable (ListT a) where ...
instance Unfoldable (ListT a) where ...

然后你得到的比你讨价还价更多，而且通用的Functor实例和ListF a（！）的实例重叠。

你可以添加一层newtype包装器来解决这个问题：如果相反，你有

newtype F f x = F{ unF ::  (f x) }

instance (Bifunctor p, ForallF Foldable f, ForallF Unfoldable f, Forall (Based p f)) => Functor (F f) where
    fmap f = F . gmap f . unF

type ListT' = F ListT

然后最后是以下类型：

*Main> unF . fmap (+1) . F $ ConsT 1 $ ConsT 2 NilT
ConsT 2 (ConsT 3 NilT)

这个额外的newtype包裹层是否可以为您所接受，这是您必须要做的事情。

Haskell - 使用递归方案的通用多态代数数据类型的Functor实例

问题：

尝试：

更新

1 个答案: