Все типы дифференциации Monads

Question

Учитывая differentiable type, мы знаем, что its Zipper is a Comonad. В ответ на это Дэн Бертон спросил: «Если вывод делает comonad, значит ли это, что интеграция делает монаду? Или это глупость?». Я хотел бы задать этот вопрос конкретному значению. Если тип дифференцируемый, это обязательно монада? одна формулировка вопроса будет просить, учитывая следующие определения

data Zipper t a = Zipper { diff :: D t a, here :: a } 

deriving instance Diff t => Functor (Zipper t) 

class (Functor t, Functor (D t)) => Diff t where 
    type D t :: * -> * 
    up :: Zipper t a -> t a 
    down :: t a -> t (Zipper t a) 

мы можем написать функции с подписями, похожими на

return :: (Diff t) => a -> t a 
(>>=) :: (Diff t) => t a -> (a -> t b) -> t b 

повинуясь Monad laws.

В ответах на связанные вопросы были два успешных подхода к аналогичной проблеме получения Comonad экземпляров для Zipper. Первый подход - expand the Diff class to include the dual of >>= and use partial differentiation. Второй подход - require that the type be twice or infinitely differentiable.

Answer 1

№ Функция пустоты data V a является дифференцируемой, но return не может быть реализован для нее.

Answer 2

Мы можем unsurprising получить Monad для чего-то подобного, если мы полностью отменим все. Ниже приведено наше предыдущее заявление и новые заявления. Я не совсем уверен, что класс, определенный ниже, фактически является интеграцией, поэтому я не буду ссылаться на него явно как таковой.

 
if D t is the derivative of t then the product of D t and the identity is a Comonad 
if D' t is the ???  of t then the sum  of D' t and the identity is a Monad 

Сначала мы определим оппозит Zipper, в Unzipper. Вместо продукта это будет сумма.

data Zipper t a = Zipper { diff :: D t a , here :: a } 
data Unzipper t a =   Unzip (D' t a) | There a 

An Unzipper является Functor тех пор, пока D' t является Functor.

instance (Functor (D' t)) => Functor (Unzipper t) where 
    fmap f (There x) = There (f x) 
    fmap f (Unzip u) = Unzip (fmap f u) 

Если вспомнить класс Diff

class (Functor t, Functor (D t)) => Diff t where 
    type D t :: * -> * 
    up :: Zipper t a -> t a 
    down :: t a -> t (Zipper t a) 

класс вещей напротив него, Diff', то же самое, но с каждым экземпляром Zipper заменен Unzipper и порядка -> стрелки перевернутого ,

class (Functor t, Functor (D' t)) => Diff' t where 
    type D' t :: * -> * 
    up' :: t a -> Unzipper t a 
    down' :: t (Unzipper t a) -> t a 

Если мы используем мой solution to the previous problem

around :: (Diff t, Diff (D t)) => Zipper t a -> Zipper t (Zipper t a) 
around z@(Zipper d h) = Zipper ctx z 
    where 
     ctx = fmap (\z' -> Zipper (up z') (here z')) (down d) 

мы можем определить обратную той функции, которая будет join для Monad.

inside :: (Diff' t, Diff' (D' t)) => Unzipper t (Unzipper t a) -> Unzipper t a 
inside (There x) = x 
inside (Unzip u) = Unzip . down' . fmap f $ u 
    where 
     f (There u') = There u' 
     f (Unzip u') = up' u' 

Это позволяет нам написать Monad экземпляр для Unzipper.

instance (Diff' t, Diff' (D' t)) => Monad (Unzipper t) where 
    return = There 
    -- join = inside 
    x >>= f = inside . fmap f $ x 

Этот экземпляр находится в том же ключе, что и Comonad например, для Zipper.

instance (Diff t, Diff (D t)) => Comonad (Zipper t) where 
    extract = here 
    duplicate = around