Show Menu
Cheatography

Haskell patterns Cheat Sheet by

Compos­ition and applic­ation

(.) :­: (­b -­> c­) -­> (­a -­> b­) -­> a -­> c
function compos­ition
($) :­: (­a -­> b­) -­> a­ -> b
applic­ation operator, has low, right-­ass­oci­ative binding preced­ence, for example f $ g­ $ ­h x­  =­  f­ (g­ (h­ x))

Monoid

typeclass where empty/­append are defined
mempt­y  ­:: ­Monoid a => a
identity of mappend (mappend mempty x = x)
mappe­nd :: Monoid a => a -> a -> a
append two monoids (assoc­iative: brackets does not matter)
mappend x (mappend y z) = mappend (mappend x y) z
<>­   ­   ­:: ­Monoid m => m -> m -> m
infix synonym for mappend ("h­e" <> "­llo­")
mconc­at :: [a] -> a
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

Applic­ative

typeclass where pure­/<­*> are defined
have Functor as super class

every instance of Appli­cative must have instance of Functor
so fmap (map­/<­$>) can be used
pure :: Applic­ative 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
(<­*>) :: Applic­ative f => f (a -> b) -> f a -> f b
sequential applic­ation / apply
Just (+1) <*> Just 1 :: Maybe Int is Just 2
[(+1), (+2)] <*> [0] :: [Int] is [1, 2]

Monad

typeclass
have Appli­cative as super class

every instance of Monad must have instance of Appli­cative and Functor
so fmap (map­/<­$>) and <*­>pure can be used
return :: Monad m => a -> m a
is pure
(>­>) :: Monad m => m a -> m b -> m b
sequen­tially 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, sequen­tially 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 []
 

Comments

No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

          GHC and RTS Options Cheat Sheet

          More Cheat Sheets by logcat