Каждая линза — это обход… как?

Lens' работает для всех функторов, включая все аппликативные функторы, поэтому, если функция g является Lens', то g также является Traversal'.

Traversal' работает для всех аппликативных функторов, но не обязательно для всех функторов. Таким образом, если функция h является Traversal', это не обязательно Lens'.

(Я не тот, кто описывает это формально, но, по крайней мере, мне кажется, что типы «контравариантны» в своих ограничениях. Lens' является подтипом Traversal' именно потому, что Functor является суперклассом Applicative.)

Обычно я не сторонник милых аналогий с «существами из реального мира», но этот вопрос, вероятно, станет яснее, если рассмотреть следующий пример:

class Animal a where feed :: a -> ArmouredGlove -> IO String

instance Animal Cat where feed _ _ = print "Miaow"
instance Animal Dog where feed _ _ = print "Woof"
instance Animal Lion where feed _ _ = print "Rwaaar"

class Animal a => Pet a where cuddle :: a -> UnprotectedHand -> IO String

instance Pet Cat where cuddle _ _ = print "Purr"
instance Pet Dog where cuddle _ _ = print "Yawn"

type PetOwner = ∀ a . Pet a => a -> IO String
type ZooWarden = ∀ a . Animal a => a -> IO String

peter :: PetOwner
peter = \pet -> cuddle pet peter'sHand

zoey :: ZooWarden
zoey = \animal -> feed animal zoey'sGlove

Здесь ZooWarden — это подтип PetOwner. Зои прекрасно справляется с домашним животным, она может кормить любую собаку, а также львов. Но у Питера нет такой квалификации, он может обращаться только с безобидными домашними животными. Таким образом, именно потому, что он ограничен более конкретным классом животных, он сам принадлежит к более общему типу личности, чем специализированный смотритель зоопарка.

Рассмотрим представление классов типов с передачей словаря. Вот как на самом деле реализуются классы типов в GHC.

Фон

В этой форме классы типов, такие как Functor и Applicative, выглядят примерно так:

data Functor f =
  MkFunctor
    { fmap :: (a -> b) -> f a -> f b }

data Applicative f =
  MkApplicative
    { appFunctor :: Functor f
    , pure :: a -> f a
    , (<*>) :: f (a -> b) -> f a -> f b
    }

Экземпляры — это значения этих типов, например так:

listFunctor :: Functor []
listFunctor =
  MkFunctor
    { fmap = map }

Линзы и траверсы

Теперь предположим, что у нас есть линза someLens :: Lens' A B и мы хотим превратить ее в обход. Давайте расширим синоним типа и воспользуемся передачей словаря:

someLens :: Functor f -> (b -> f b) -> (a -> f a)

В этом стиле вы можете использовать его с функтором списка вот так someLens listFunctor.

Нам нужен обход someTraversal :: Traversal' A B. Когда мы реализуем это, нам нужно будет предоставить someLens значение Functor f. Но у нас уже есть значение Applicative f:

someTraversal :: Applicative f -> (b -> f b) -> (a -> f a)
someTraversal applicativeDict = someLens (appFunctor applicativeDict)

Мы можем просто использовать метод доступа к полю, который получает реализацию Functor для предоставленного нам экземпляра Applicative, и у нас есть Traversal. Поле доступа имеет тип appFunctor :: Applicative f -> Functor f.