Cheatography

Haskell patterns Cheat Sheet by logcat

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 ``mempty­  :­: M­onoid a => a`` identity of mappend (mappend mempty x = x) ``mappend :: Monoid a => a -> a -> a`` append two monoids (assoc­iative: brackets does not matter)``mappend x (mappend y z) = mappend (mappend x y) z`` ``<> ­   ­  :­: M­onoid m => m -> m -> m`` infix synonym for mappend (``"­he" <> "­llo­"``) ``mconcat :: [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 functorinfix synonym for ``fmap````(+1) <\$> (Just 3)`` is ``Just 4``

Applic­ative

 typeclass where ``pure``/``<*>`` are definedhave ``Functor`` as super class every instance of ``Applic­ative`` 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]``

 typeclasshave ``Applic­ative`` as super class every instance of ``Monad`` must have instance of ``Applic­ative`` 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 ``[]``