了解 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

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

这是我的理解：

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

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

现在：

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

2. 如果我们用Either a 替换f，我们得到fmap :: (c -> d) -> Either a c -> Either a d

3. Right (g x) 的类型是Either a (g x)，g x 的类型是d，所以我们得到Right (g x) 的类型是Either a d，这就是我们所期望的fmap（见上文 2.）

1234563 . 以上）：d 应该是第二个参数，而不是第一个！所以我们不能映射到Left。

我的推理正确吗？

Answer 1

这是对的。这种行为还有另一个非常重要的原因：您可以将Either a b 视为一个计算，它可能成功并返回b，或者失败并返回错误消息a。 （这也是 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)

Mere a 术语未被触及，()、String 和 Int 值未被触及。

Answer 3

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

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

所以我们有构造函数FlipEither :: Either a b -> FlipEither b a，它用交换的类型参数将Either 包装到我们的newtype 中。我们有 dectructor unFlipEither :: FlipEither b a -> Either a 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 的情况下实现映射 正确的值构造函数，但没有 在左派的情况下？

在此处插入，它可能有意义。

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

所以你有一个 f: Float -> Integer 比如说四舍五入。

（任意字符串）（浮点数）= 任意字符串浮点数。

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

换句话说，Eather a 是一个函子，因为有这样一个明显的 fmap：

• 对于右值应用 f
• 对于左值什么都不做