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 []

Help Us Go Positive!

We offset our carbon usage with Ecologi. Click the link below to help us!

We offset our carbon footprint via Ecologi
 

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