Cheatography
https://cheatography.com
Composition and application(.) :: (b -> c) -> (a -> b) -> a -> c
| function composition | ($) :: (a -> b) -> a -> b
| application operator, has low, right-associative binding precedence, for example f $ g $ h x = f (g (h x)) |
Monoidtypeclass 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") | mconcat :: [a] -> a
| fold list using mappend and mempty |
Functortypeclass 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 |
Applicativetypeclass 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] |
Monadtypeclass
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
| is pure | (>>) :: 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