理解 Either 如何成为 Functor 的一个实例

Question

在我的空闲时间我正在学习 Haskell，所以这是一个初学者问题。

在我的阅读中，我遇到了一个示例，说明如何将 Either a 制作为 Functor 的实例：

instance Functor (Either a) where
    fmap f (Right x) = Right (f x)
    fmap f (Left x) = Left x

现在，我试图理解为什么在 a 的情况下实现映射Right 值构造函数，但在 Left 的情况下却不是？

这是我的理解：

首先让我将上面的实例重写为

instance Functor (Either a) where
    fmap g (Right x) = Right (g x)
    fmap g (Left x) = Left x

现在：

1. 我知道 fmap :: (c -> d) -> fc-> f d

2. 如果我们将 f 替换为 Either a，我们会得到 fmap :: (c -> d) ->要么 ac ->或者 a d

3. Right (gx)的类型是要么是a (gx)，而g x的类型是d，因此我们得到 Right (gx) 的类型是 Either a d，这正是我们对 fmap 的期望code> （参见上面的 2.）

4. 现在，如果我们查看 Left (gx)，我们可以使用相同的推理来判断它的类型是 Either (gx) b，即 Either d b，这不是我们对 fmap 的期望（参见上面的 2.）：d 应该是第二个参数，而不是第一个！因此我们无法映射 Left。

我的推理正确吗？

Answer 1

这是对的。这种行为还有另一个非常重要的原因：您可以将 Either a b 视为计算，它可能成功并返回 b 或失败并显示错误消息 一个。 （这也是 monad 实例的工作原理）。因此，函子实例不会触及 Left 值是很自然的，因为您想要映射计算，如果失败，则没有任何可操作的。

Answer 2

你的账户当然是对的。也许我们在处理这样的实例时遇到困难的原因是我们实际上一次定义了无限多个函子实例——每个可能的 Left 类型都有一个实例。但 Functor 实例是一种对系统中无限多种类型进行操作的系统方法。因此，我们定义了对系统中无限多种类型进行系统操作的无限多种方法。这个例子在两个方面涉及普遍性。

不过，如果你分阶段来看，也许就不那么奇怪了。第一个类型是使用单元类型 () 及其唯一合法值 () 的冗长版本的 Maybe：

data MightBe b     = Nope ()    | Yep b
data UnlessError b = Bad String | Good b
data ElseInt b     = Else Int   | Value b

在这里我们可能会得到累了并进行抽象：

data Unless a b    = Mere a     | Genuine b

现在我们毫无问题地创建 Functor 实例，第一个看起来很像 Maybe 的实例：

instance Functor MightBe where
  fmap f (Nope ()) = Nope ()   -- compare with Nothing
  fmap f (Yep x)   = Yep (f x) -- compare with Just (f x)

instance Functor UnlessError where
  fmap f (Bad str) = Bad str   -- a more informative Nothing
  fmap f (Good x)  = Good (f x)

instance Functor ElseInt where
  fmap f (Else n) = Else n 
  fmap f (Value b) = Value (f b)

，再一次，为什么要麻烦，让我们进行抽象：

instance Functor (Unless a) where
  fmap f (Mere a) = Mere a
  fmap f (Genuine x) = Genuine (f x)

但是 a 项未受影响，因为 ()、String 和 Int 值未受影响。

Answer 3

正如其他人提到的，Either 类型在其两个参数中都是一个函子。但在 Haskell 中，我们能够（直接）在类型的最后一个参数中仅定义函子。在这种情况下，我们可以使用 newtype 来绕过限制：

newtype FlipEither b a = FlipEither { unFlipEither :: Either a b }

因此我们有构造函数 FlipEither :: Either ab -> FlipEither b a 将 Either 包装到带有交换类型参数的 newtype 中。我们有析构函数 unFlipEither :: FlipEither ba ->要么是 b 将其解开。现在我们可以在 FlipEither 的最后一个参数中定义一个函子实例，它实际上是 Either 的第一个参数：

instance Functor (FlipEither b) where
    fmap f (FlipEither (Left x))  = FlipEither (Left (f x))
    fmap f (FlipEither (Right x)) = FlipEither (Right x)

请注意，如果我们忘记 FlipEither有一段时间，我们只得到了 Either 的 Functor 定义，只是交换了 Left/Right 。现在，每当我们在 Either 的第一个类型参数中需要 Functor 实例时，我们都可以将该值包装到 FlipEither 中，然后再将其解开。例如：

fmapE2 :: (a -> b) -> Either a c -> Either b c
fmapE2 f = unFlipEither . fmap f . FlipEither

---

更新：查看Data.Bifunctor，其中 Either 和 (,) 是其实例。每个 bifunctor 有两个参数，并且每个参数都是一个函子。这反映在 Bifunctor 的方法 first 和 second 中。

Either 的 Bifunctor 的定义非常对称：

instance Bifunctor Either where
    bimap f _ (Left a)  = Left (f a)
    bimap _ g (Right b) = Right (g b)

    first  f = bimap f id

    second f = bimap id f

Answer 4

现在，我试图理解为什么
实施图的情况下
正确的值构造函数，但不是
如果是左派？

插在这里，它可能会有意义。

假设 a = String （错误消息）
您将 Either a 应用于 Float。

所以你有一个 f: Float ->整数例如四舍五入。

（任一字符串）（浮点型）= 任一字符串浮点型。

now (fmap f):: 要么字符串浮点 ->要么 字符串 Int
那么你打算用 f 做什么呢？ f 不知道如何处理字符串，所以你不能在那里做任何事情。 显然您唯一可以采取的行动就是选择正确的值，同时保持左侧的值不变。

换句话说，a 是一个函子，因为有一个明显的 fmap 给出：

• 对于 Right 值，应用 f
• 对于 Left 值，不执行任何操作