Понимание того, как Либо является экземпляром Functor

Это правильно. Есть еще одна очень важная причина такого поведения: вы можете думать о Either a b как о вычислении, которое может завершиться успешно и вернуть b или завершиться ошибкой с сообщением об ошибке a. (Это также то, как работает экземпляр монады). Поэтому вполне естественно, что экземпляр функтора не будет касаться значений Left, поскольку вы хотите отобразить вычисление, если оно не удастся, манипулировать нечем.

Ваш счет, конечно, прав. Возможно, причина, по которой у нас возникают трудности с подобными экземплярами, заключается в том, что мы на самом деле определяем бесконечно много экземпляров функторов одновременно — по одному для каждого возможного типа 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 не затрагиваются.

Как уже упоминалось, тип Either является функтором в обоих аргументах. Но в Haskell мы можем (напрямую) определять только функторы в последних аргументах типа. В подобных случаях мы можем обойти ограничение, используя newtypes:

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

Итак, у нас есть конструктор FlipEither :: Either a b -> FlipEither b a, который оборачивает Either в наш newtype с переставленными аргументами типа. И у нас есть деструктор 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, мы получим только определение Functor для Either, просто поменяв местами Left/Right. И теперь, всякий раз, когда нам нужен экземпляр Functor в аргументе первого типа Either, мы можем обернуть значение в FlipEither и затем развернуть его. Например:

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

Обновление: посмотрите Data.Bifunctor, экземплярами которого являются Either и (,). Каждый бифунктор имеет два аргумента и является функтором в каждом из них. Это отражено в методах Bifunctor first и second.

Определение Bifunctor из Either очень симметрично:

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

Теперь я пытаюсь понять, почему реализация отображается в случае конструктора значения Right, но не в случае левого?

Включите здесь, и это может иметь смысл.

Предположим, что a = String (сообщение об ошибке). Вы применяете либо a к Float.

Итак, у вас есть f: Float -> Integer, скажем, например, округление.

(Любая строка) (Плавающая) = Любая строка с плавающей запятой.

теперь (fmap f):: Либо String Float -> Либо String Int Итак, что вы собираетесь делать с f? f понятия не имеет, что делать со строками, поэтому вы ничего не можете там сделать. Это очевидно, единственное, на что вы можете воздействовать, — это правильные значения, оставляя левые значения без изменений.

Другими словами, Либо a является функтором, потому что существует такое очевидное отображение fmap, которое задается следующим образом:

• для правильных значений применяются f
• для левых значений ничего не делать