Monoidal natural transformations / Applicative morphisms / Applicative functor morphism / Applicative transformation (used in Data.Foldable)

Monoidal.markdown

https://mail.haskell.org/pipermail/haskell-cafe/2010-November/086055.html

http://conal.net/blog/posts/simplifying-semantics-with-type-class-morphisms

http://conal.net/blog/posts/another-lovely-example-of-type-class-morphisms

https://arxiv.org/pdf/1202.2919.pdf

eta (pure c) = pure c
eta (f <*> x) = eta f <*> eta x

Applicative (Sum f g): https://gist.github.com/Icelandjack/78542ddbdb622a48d8e60e14510cd7dd

Examples

In addition to these we have some uninteresting ones.

I don't think there are any transformations Maybe ~> (m, ) but there is (a unique?) one

a :: (m, ) ~> Maybe
a (_, m) = Just m

pure for [] and ZipList is

pure @[]      a = [a]
pure @ZipList a = ZipList (repeat a)

so a natural transformation must take [()] to ZipList (repeat ()).. infinite lists, seems to follow laws but not interesting

b :: [] ~> ZipList 
b xs = ZipList (concatMap repeat xs)

c :: NonEmpty ~> []
c = toList

d :: [] ~> Compose Maybe NonEmpty
d []     = Compose $ Nothing
d (x:xs) = Compose $ Just (x:|xs)

e :: Either e ~> []
e = toList

f :: Maybe ~> []
f = toList

g :: a -> Maybe ~> Either a
g val = maybe (Left val) Right

Either : (->) -> (~>)

h :: (a -> a') -> (Either a ~> Either a')
h = first

?: This is a monoidal natural transformation when a -> a' is a monoid homomorphism?

i :: (a -> a') -> ((,) a ~> (,) a')
i = first 

runAp f is a monoidal natural transformation for all f, this is exciting :)

According to https://arxiv.org/pdf/1202.2919.pdf

join' :: Monad m => Compose m m ~> m
join' (Compose mma) = join mma

cmp to

(Functor f, Applicative g) 
  => f ~> Compose f g
(Applicative f)
  => g ~> Compose f g

In categories monoidal wrt the Day convolution, the exponential

data Exp :: (* -> *) -> (* -> *) -> (* -> *) where
  Exp :: (forall xx. f xx -> g (a, xx)) -> Exp f g a

has a Caley representation

data Rep :: (* -> *) -> (* -> *) where
  Rep :: (forall xx. f xx -> f (a, xx)) -> Rep f a
  deriving Functor

instance Functor f => Applicative (Rep f) where
  pure = Rep . fmap . (,)

  Exp f <*> Exp a = Exp (fmap g . a . f) where
    g (x, (f, c)) = (f x, c)

then http://usuarios.fceia.unr.edu.ar/~mauro/pubs/Notions_of_Computation_as_Monoids_ext.pdf claims rep is monoidal

rep :: Applicative f => f ~> Rep f
rep x = Rep (\y -> pure (,) <*> x <*> y)

Testing: https://s3.amazonaws.com/haddock.stackage.org/nightly-2015-05-21/checkers-0.4.3/Test-QuickCheck-Classes.html#v:applicativeMorphism

? Monad morphism implies applicative morphism

A Unied View of Monadic and Applicative Non-determinism

A Unied View of Monadic and Applicative Non-determinism

Ideal monad / idealized monad / unital monads

Control.Applicative.Lift + https://www.reddit.com/r/haskell/comments/6ac1x2/idealised_monads_or_monad_instance_for_lift_f/

data UM m a = Pure a | Impure (m a)

class Functor m => Unital m where
  join :: m (UM m a) -> UM m a

http://r6.ca/blog/20121209T182914Z.html