Почему в Haskell нет класса «Кофейник»?

Question

Monads получает fmap от Functor typeclass. Почему comonads не нужен метод cofmap, определенный в классе Cofunctor?

Answer 1

Functor определяется как:

class Functor f where 
    fmap :: (a -> b) -> (f a -> f b) 

Cofunctor может быть определена следующим образом:

class Cofunctor f where 
    cofmap :: (b -> a) -> (f b -> f a) 

Таким образом, оба технически же, и именно поэтому Cofunctor не существует. «Двойное понятие« функтора вообще »по-прежнему является« функтором вообще »».

С Functor и Cofunctor такие же, как монады, так и комонады определяются с помощью Functor. Но не позволяйте этому заставлять вас думать, что монады и комонады - это одно и то же, а это не так.

Монадой определяется (упрощение), как:

class Functor m => Monad where 
    return :: a -> m a 
    (>>=) :: m a -> (a -> m b) -> m b 

является ли комонадой (опять же, упрощенный):

class Functor w => Comonad where 
    extract :: w a -> a 
    extend :: (w a -> b) -> w a -> w b 

Обратите внимание на "симметрии".

---

Другое дело контравариантный функтор, определяемый как:

import Data.Functor.Contravariant 
class Contravariant f where 
    contramap :: (b -> a) -> (f a -> f b) 

Answer 2

Для справки,

class Functor w => Comonad w where 
    extract :: w a -> a 
    duplicate :: w a -> w (w a) 
    extend :: (w a -> b) -> w a -> w b 

instance Applicative m => Monad m where 
    return :: a -> m a 
    (>>=) :: m a -> (a -> m b) -> m b 

join :: Monad m => m (m a) -> m a 

Обратите внимание, что данный extract и extend вы можете производить fmap и duplicate, и что, учитывая return и >>= вы можете произвести fmap, pure, <*> и join. Поэтому мы можем сосредоточиться только на pure + >>= и extract + extend.

Я полагаю, вы могли бы искать что-то вроде

class InverseFunctor f where 
    unmap :: (f a -> f b) -> a -> b 

Поскольку Monad класс позволяет легко «навести» в то время как только позволяет некий гипотетический подход к «принимая вещи», и Comonad что-то противное, ваш запрос изначально звучит разумно. Тем не менее, существует значительная асимметрия между >>= и extend, которая будет мешать любой попытке определить unmap. Обратите внимание, в частности, что первый аргумент >>= имеет тип m a. Второй аргумент extend имеет тип w a — неa.

Answer 3

Собственно, вы ошибаетесь: есть один!

https://hackage.haskell.org/package/acme-cofunctor