Question

阅读了本书Learn you a Haskell For Great Good以及帮助我克服常见类别错误Haskell Category Theory的非常有用的维基书籍文章of confusing category objects with the programming objects后，我仍然有以下问题：

为什么fmap必须映射列表的每个元素？

我喜欢它，我只是想理解这在理论上是如何合理的。（或者更容易证明使用HoTT？）

在Scala表示法中，List是一个仿函数，它接受任何类型并将其映射到所有列表类型集合中的类型，例如，它将类型Int映射到类型{{1}并且它映射List[Int]上的函数，例如

Int至Int.successor: Int => Int
Functor[List].fmap(successor) : List[Int] => List[Int]至Int.toString: Int => String

现在Functor[List].fmap(toString): List[Int] => List[String]的每个实例都是一个幺半群，其中empty function（Haskell中为List[X]）和combine function（Haskell中为mempty）。我的猜测是，可以使用Lists为Monoids的事实，以表明mappend必须映射列表的所有元素。我的感觉是，如果添加pure function from Applicative，这给了我们一个列表，其中只包含一个其他类型的元素。例如map。由于这些元素上的Applicative[List[Int]].pure(1) == List(1)为我们提供了包含下一个元素的单例列表，因此这涵盖了所有这些子集。然后我想所有这些单身人士的map(succ)函数给了我们列表中所有其他元素。不知怎的，我想这会限制地图的运作方式。

另一个有争议的论点是combine必须在列表之间映射函数。由于map中的每个元素都是Int类型，并且如果一个元素映射到List[Int]，则必须映射它的每个元素，或者一个元素不是正确的类型。

所以这两个论点似乎都指向了正确的方向。但我想知道剩下的工作还需要什么。

反例吗

为什么这不是反例地图功能？

List[String]

似乎遵循规则

def map[X,Y](f: X=>Y)(l: List[X]): List[Y] = l match {
  case Nil => Nil
  case head::tail=> List(f(head))
}

稀释。但它不符合id法。

val l1 = List(3,2,1)
val l2 = List(2,10,100)

val plus2 = (x: Int) => x+ 2
val plus5 = (x: Int) => x+5

map(plus2)(List()) == List()
map(plus2)(l1) == List(5)
map(plus5)(l1) == List(8)

map(plus2 compose plus5)(l1) == List(10)
(map(plus2)_ compose map(plus5)_)(l1) == List(10)

Answer 1

这取决于称为“参数化”的理论结果，首先由雷诺兹定义，然后由瓦德勒（以及其他人）开发。也许关于这一主题的最着名的论文是Wadler的"Theorems for free!"。

关键的想法是，从函数的多态类型，我们可以获得有关函数语义的一些信息。例如：

foo :: a -> a

仅从这种类型中，我们可以看到，如果foo终止，则它是身份功能。直观地说，foo无法区分不同的a，因为在Haskell中我们没有例如instanceof。 Java的bar :: a -> b -> a可以检查实际的运行时类型。类似地，

baz :: a -> a -> a

必须返回第一个参数。 quz :: a -> (a -> a) -> a必须返回第一个或第二个。并且map必须将函数的固定次数应用于第一个参数。你现在可能已经明白了这个想法。

可以从类型推断的一般属性非常复杂，但幸运的是它可以计算mechanically。在类别理论中，这与natural transformation的概念有关。

对于forall t1,t2 in TYPES, f :: t1 -> t2. forall t3,t4 in TYPES, g :: t3 -> t4. forall p :: t1 -> t3. forall q :: t2 -> t4. (forall x :: t1. g (p x) = q (f x)) ==> (forall y :: [t1]. map_{t3}_{t4} g (map2_{t1}_{t3} p y) = map2_{t2}_{t4} q (map_{t1}_{t2} f y))类型，我们得到以下可怕属性：

map

上面，map2是众所周知的地图函数，而(a -> b) -> [a] -> [b]是任意类型为map2的函数。

现在，进一步假设map2 id = id满足仿函数法则，特别是p = id。然后，我们可以选择t3 = t1和forall t1,t2 in TYPES, f :: t1 -> t2. forall t4 in TYPES, g :: t1 -> t4. forall q :: t2 -> t4. (forall x :: t1. g x = q (f x)) ==> (forall y :: [t1]. map_{t1}_{t4} g (map2_{t1}_{t1} id y) = map2_{t2}_{t4} q (map_{t1}_{t2} f y))。我们得到

map2

在forall t1,t2 in TYPES, f :: t1 -> t2. forall t4 in TYPES, g :: t1 -> t4. forall q :: t2 -> t4. (forall x :: t1. g x = q (f x)) ==> (forall y :: [t1]. map_{t1}_{t4} g y = map2_{t2}_{t4} q (map_{t1}_{t2} f y))上应用仿函数法：

t2 = t1

现在，让我们选择f = id和forall t1 in TYPES. forall t4 in TYPES, g :: t1 -> t4. forall q :: t1 -> t4. (forall x :: t1. g x = q x) ==> (forall y :: [t1]. map_{t1}_{t4} g y = map2_{t1}_{t4} q (map_{t1}_{t1} id y))：

map

根据forall t1, t4 in TYPES. forall g :: t1 -> t4, q :: t1 -> t4. g = q ==> (forall y :: [t1]. map_{t1}_{t4} g y = map2_{t1}_{t4} q y)的算子法：

forall t1, t4 in TYPES.
 forall g :: t1 -> t4.
    (forall y :: [t1].
          map_{t1}_{t4} g y =
          map2_{t1}_{t4} g y)

表示

forall t1, t4 in TYPES.
          map_{t1}_{t4} = map2_{t1}_{t4}

表示

map2

总结：

如果(a -> b) -> [a] -> [b]是具有多态类型map2 id = id的任何函数，并且它满足第一个仿函数法map2，那么map必须等同于标准x.isInstanceOf[] 1}}功能。

另见related blog post by Edward Kmett。

请注意，在Scala中，只有当您不使用{{1}}和其他可能破坏参数的反射工具时，上述情况才会成立。

为什么fmap必须映射List的每个元素？

1 个答案: