haskell - 为什么只有 Applicative 需要 `pure` 而 Functor 不需要？

Question

这个问题在这里已经有了答案:





Why Functor class has no return function?

(4 个回答)


2年前关闭。




阅读 this Wikibook about Haskell and Category Theory basics ，我了解仿函数:

A functor is essentially a transformation between categories, so given categories C and D, a functor F : C -> D

maps any object A in C to F(A), in D.

maps morphisms f : A -> B in C to F(f) : F(A) -> F(B) in D.

...听起来不错。稍后提供一个示例:

Let's have a sample instance, too:

instance Functor Maybe where
  fmap f (Just x) = Just (f x)
  fmap _ Nothing  = Nothing

Here's the key part: the type constructor Maybe takes any type T to a new type, Maybe T. Also, fmap restricted to Maybe types takes a function a -> b to a function Maybe a -> Maybe b. But that's it! We've defined two parts, something that takes objects in Hask to objects in another category (that of Maybe types and functions defined on Maybe types), and something that takes morphisms in Hask to morphisms in this category. So Maybe is a functor.

我理解 fmap 的定义如何是关键。我对“类型构造函数 Maybe”如何提供第一部分感到困惑。我宁愿期待 pure .

如果我猜对了， Maybe而是 map C至 D . (因此是类别级别的态射，这可能是 Functor 的要求)

我想你可以这样改写我的问题:是否有一个 Functor 没有明显的 pure 实现？ ?

Answer 1

我认为您在类型和值之间感到困惑。下面是仿函数的定义:

Let C and D be categories. A functor F from C to D is a mapping that:

• associates to each object X ∈ C an object F(X) ∈ D.

• associates to each morphism f : X → Y ∈ C a morphism F(f) : F(X) → F(Y) ∈ D such that the following conditions hold:

  • F(id : X → X) = id : F(X) → F(X) for every object X ∈ C.
  • F(g ∘ f) = F(g) ∘ F(f) for all morphisms f : X → Y and g : Y → Z.

范畴由对象和对象之间的态射组成。
Haskell 中的所有代码都是 Hask 的一部分，Haskell 类别。在哈斯克:

类型是对象。

函数是类型之间的态射。

因此，所有 Functor Haskell 中的实例是从 Hask 到 Hask 的仿函数(即它们是内仿函数)。
更严格地说，对于 Functor 的所有实例在 haskell :

C = Hask .

D = Hask .

现在，每个仿函数 F 是一个映射，它与每个对象 X ∈ C 关联一个对象 F(X) ∈ D。

注意 X 和 F(X) 分别是 C 和 D 的对象。

由于 C 和 D 都是 Hask，因此 X 和 F(X) 都是类型而不是值。

因此，F : Type → Type or in Haskell f : * -> * .

确实，这正是 Functor类型类在 Haskell 中定义:

class Functor (f : * -> *) where
    fmap :: (x -> y) -> (f x -> f y)

在这里， fmap是仿函数的第二部分。这是一个从值到值的函数。但是， Functor本身是一个类型构造函数(即从类型到类型的映射)。这就是原因 Maybe是仿函数和 []是仿函数，但 Maybe Int和 [Int]不是仿函数。
请注意 pure不构成仿函数定义的第一部分，因为它是从 X 的实例到 F(X) 的实例的映射(即它是从值到值的函数)。但是，我们需要从 X 到 F(X) 的映射(即从类型到类型的映射)。