Cheatography
https://cheatography.com
Composition and application
(.) :: (b > c) > (a > b) > a > c

function composition 
($) :: (a > b) > a > b

application operator, has low, rightassociative binding precedence, for example f $ g $ h x = f (g (h x))

Monoid
typeclass where empty/append are defined 
mempty :: Monoid a => a

identity of mappend (mappend mempty x = x) 
mappend :: Monoid a => a > a > a

append two monoids (associative: brackets does not matter) mappend x (mappend y z) = mappend (mappend x y) z

<> :: Monoid m => m > m > m

infix synonym for mappend ( "he" <> "llo"
) 

fold list using mappend and mempty 
Functor
typeclass where fmap
( map
/ <$>
) is defined 
should satisfy laws 
fmap id == id
fmap (f . g) == fmap f . fmap g

fmap :: Functor f => (a > b) > f a > f b

map function over functor fmap (+1) (Just 3)
is Just 4

<$> :: Functor f => (a > b) > f a > f b

function mapped over functor infix synonym for fmap
(+1) <$> (Just 3)
is Just 4

Applicative
typeclass where pure
/ <*>
are defined have Functor
as super class 
every instance of Applicative
must have instance of Functor
so fmap
( map
/ <$>
) can be used 
pure :: Applicative f => a > f a

create an instance of Applicative pure 3 :: [Int]
is [3]
pure 3 :: Maybe Int
is Just 3
pure (+3) :: Maybe (Int > Int)
is Just
a function from Int to Int pure (+3) :: [Int > Int]
is list of function pure 1 :: IO Int
is how it is printed in ghci 
(<*>) :: Applicative f => f (a > b) > f a > f b

sequential application / apply Just (+1) <*> Just 1 :: Maybe Int
is Just 2
[(+1), (+2)] <*> [0] :: [Int]
is [1, 2]

Monad
typeclass have Applicative
as super class 
every instance of Monad
must have instance of Applicative
and Functor
so fmap
( map
/ <$>
) and <*>
/ pure
can be used 
return :: Monad m => a > m a


(>>) :: Monad m => m a > m b > m b

sequentially compose two monads, first is usually Just 2 >> Just 3
is Just 3
Nothing >> Just 3
is Nothing
[9, 9] >> [0, 0, 0]
is [0,0,0,0,0,0]

(>>=) :: Monad m => m a > (a > m b) > m b

bind, sequentially compose two monads, value of first passed as argument to the second Just 3 >>= \x > Just (x + 1)
is Just 4
Nothing >>= \x > Just (x + 1)
is Nothing
[0, 0] >>= \x > [x + 1]
is [1, 1]
[0, 0] >>= \x > [x + 1, 2]
is [1,2,1,2]
[] >>= \x > [x + 1]
is []


Created By
Metadata
Comments
No comments yet. Add yours below!
Add a Comment
Related Cheat Sheets
More Cheat Sheets by logcat