在 Haskell 中，如何在不同的 Traversable 之间进行 fmap？

Question

我们知道，fmap 的签名是(a -> b) -> f a -> f b，其中f 是Functor。

为了尽可能通用，更好地分解代码，人们可能希望将“事物列表”映射到另一个可能不同的“事物列表”，这似乎很自然。凭直觉，我不明白为什么它不可行或不可取。

我正在寻找的是一个函数gmap，其行为与fmap 相同，但具有gmap :: (a -> b) -> (f a) -> (g b) 的签名，我允许到达和离开容器不同。

我不确定这在f 和g 是Functors 的一般情况下是否有意义，但是“事物列表”的概念听起来更本质上是由Traversable 类捕获的，假设我最感兴趣的是迭代数据。

所以也许签名应该是gmap :: (Traversable f, Traversable g) => (a -> b) -> (f a) -> (g b)。

即使g 与f 的性质不同，它仍然是可以从左到右遍历的东西，所以仍然感觉应该能够将f 的第k 个访问元素映射到g 的第 k 个访问元素。

假设我的思路没有出错，Haskell中有这样的功能吗？

本质上，我的问题是，您如何在 Haskell 中以最简洁和优雅的方式将一个类似列表的东西转换为另一个？

Answer 1

我们在 Haskell 中经常使用的一个技巧是试图用它来产生“假”——也就是产生一个类型的值

data Void

没有构造函数的类型。如果可以使用您的类型签名生成Void 类型的值，那么您的类型签名将无法实现。这也被称为“reducto ad absurdum”或“反证法”。如果您的类型签名允许我们生成Void...类型的值...那么“显然”您的类型签名是废话，无法实现。

在这种情况下，我们“返回”了一个Traversable 实例，所以让我们使用Traversable，比如(,) Void：

instance Traversable ((,) w) where
    traverse f (x, y) = (x,) <$> f y

现在让我们使用f 作为任何旧仿函数。它可以是任何东西......让我们使用Maybe，因为似乎每个人都已经理解它了。

那么，你可以这样写：

gmap :: (a -> b) -> Maybe a -> (Void, b)

哦，不，这不对……看起来使用 gmap 你可以通过传入任何旧的东西来创建Void：

gmap :: (() -> ()) -> Maybe () -> (Void, ())

所以现在我创建Void的策略：

bad :: Void
bad = fst (gmap id Nothing)

因为Void 没有构造函数，所以不应该存在bad :: Void 类型的值（忽略诸如无限循环或偏函数之类的东西）。所以，如果仅仅存在 if gmap 就可以让我们创建一个 Void 类型的值...那一定意味着 gmap 不能以你给的形式存在。

---

对于您更普遍的问题，Traversable 工作方式的“原因”是它只能修改 结构。它不能创建它们。在这里，你想创建一个g b 的值，但是Traversable 不能“创建”它，它只能“转换”它。您的误解可能来自您认为Traversable 是一个“类似列表”的类型类：它不是，完全不是。使用 [] 作为原型可能会让你误入歧途。

我的“典型”Traversable 想象类型类的属性是Map k，来自容器 的Data.Map：Map 不是一个，而是相关的值用钥匙。对其进行的任何操作都必须能够尊重此关联属性...而不是将其视为没有额外结构的大列表。

所以 可能是这样的：

replace :: (Foldable f, Traversable g) => f a -> g b -> g a

g b 的所有值都替换为f a 的所有值。如果您正在寻找练习，这实际上是一种有趣的写作。基本上，replace 将保持与g a 相同的结构，但只是替换 值 .所以你可以从f a“创建”一个g a，只要你有一个“示例g b”，可以这么说。如果你使用类似的东西：

replace :: [a] -> Map k b -> Map k a

然后replace 将用列表中的项目替换第二个映射中的所有值，并将它们替换为正确的键值。

然后你可以写：

gmap :: (Traversable a, Traversable g) => (a -> b) -> f a -> g c -> g b

在哪里你要复制的结构的“示例”g a。

最接近能够在 Haskell 的常见类型类中“构造”结构的方法是 IsList，来自 https://hackage.haskell.org/package/base-4.12.0.0/docs/GHC-Exts.html#t:IsList

这个类型类给你两个函数，fromList 和toList，所以你可以这样写：

throughIsList :: (IsList l, IsList m, Item l ~ Item m) => l -> m
throughIsList = fromList . toList

让它在Functors 上运行：

gmap :: (IsList (f a), IsList (g b), Item (f a) ~ a, Item (g b) ~ b) => (a -> b) -> f a -> g b
gmap f = fromList . map f . toList

现在的问题是大多数Functors 不是IsList 的实例...而且许多实际实例不是全部。所以它对大多数Functors 来说不太有用。

---

所以最后我认为没有任何令人满意的答案。如果您正在做的事情依赖于有一个好的答案这一事实（除了“否”的答案）......也许我可以问一下您的“最终目标”是什么？你打算用这种类型做什么？

（例如，在 90% 的情况下，人们会问诸如“有什么方法可以转换 monad”之类的问题，通常他们不想在 一般，但他们有特定的类型。）

Answer 2

您可以创建自己的类型类，以及从一个函子到另一个函子的方法，这是将列表转换为树的一种方法的示例，但您可以使用任何您认为正确的方法来解决您的问题。

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleContexts #-}

class (Functor f, Functor g) => GFunctor f g where
  toG :: f a -> g a
  gmap :: (a -> b) -> (f a) -> (g b)
  gmap fn functor = toG $ fmap fn functor

data Tree a = Leaf | Node (Tree a) a (Tree a) deriving Show

instance Functor Tree where
  fmap f Leaf = Leaf
  fmap f (Node t1 x t2) = Node (fmap f t1) (f x) (fmap f t2)

instance GFunctor [] Tree  where
  toG [] = Leaf 
  toG [x] = Node Leaf x Leaf
  toG (x:xs) = Node (toG $ (takeHalf xs)) x ((toG $ dropHald xs))

takeHalf xs = take ((length xs) `div` 2) xs
dropHald xs = drop ((length xs) `div` 2) xs

res :: Tree Int
res = gmap (+1) [1,2,3,4,5]

输出：

   res
=> Node (Node Leaf 3 (Node Leaf 4 Leaf)) 2 (Node Leaf 5 (Node Leaf 6 Leaf))

Answer 3

我认为您可以通过fmap 和自然转换来做到这一点。这是一个使用 natural-transformations 包的示例，只是为了演示这个想法。

我想到的第一个自然转变是safeHead：

safeHead :: [a] -> Maybe a
safeHead [] = Nothing
safeHead (x:_) = Just x

使用 natural-transformations 包运行 GHCi：

Prelude Control.Natural> t = wrapNT safeHead
Prelude Control.Natural> t # [1..3]
Just 1
Prelude Control.Natural> t # []
Nothing
Prelude Control.Natural> fmap show (t # [1..3])
Just "1"
Prelude Control.Natural> fmap show (t # [])
Nothing

那么，对于t 的自然转换，像fmap f . (t #) 这样的东西会做你想做的吗？

（这里，我想象f是一个普通函数a -> b。）