Haskell
Functional Programming
is scary
Unfamiliar
Functor
Mappable
Catamorphism
Collapsible
Foldable
Monad
Flatmappable
Chainable
AndThenable
Computation builder
( I'll come back to this one )
Monoid
Aggregatable
Currying
Currying?
Applicatives
Applicatives?
Object Oriented
Programming
is scary
very much so.
Inheritance
Covariance
Polymorphism
SOLID
SRP,OCP,LSP
DIP
Functional Programming
Ideas
Maths
is your
Friend
Mathematical assertions are
Precise
Mathematical assertions are usually
Generalized
( You can often apply them to many different instances )
Mathematical reasoning is/can be
Proved
Functions are pure
Given the same inputs, always will return same output
( Referential transparency )
Types
are not
Classes
What are types?
Int is a type
String is a type
User is a type
Functions
are types
Int -> Int(+3)Functions
are
Things
You can:
Return functions from functions
Pass functions as parameters
Writing functions in different ways
add :: Int -> Int -> Int
add x y = x + yadd :: Int -> Int -> Int
add = (\x y -> x + y)add :: Int -> (Int -> Int)
add x = (\y -> x + y)three = 1 + 2three = (+) 2 1add1 = (+) 2Missing a parameter?
Composition
Everywhere!
show :: Int -> Stringlength :: String -> IntdigitCount :: Int -> IntdigitCount :: Int -> Int
digitCount value = length (show value)digitCount :: Int -> Int
digitCount value = length . show valuedigitCount :: Int -> Int
digitCount = length . show . is a function!
show is (a -> b) (Int -> String)
length is (b -> c) (String -> Int)
the number you pass in is a
(.) :: (b -> c) -> (a -> b) -> a -> cFunctions
all the
Way Down
Types
are your
Friends
Use types to represent
Constraints
data Suit = Club | Diamond | Spades | Diamonddata Rank = Two
| Three
| Four
| Five
| Six
| Seven
| Eight
| Nine
| Ten
| Jack
| Queen
| King
| Acedata Card = Card Suit Ranktype Deck = [Card]Use types to indicate
Errors
parseInt :: String -> IntparseInt :: String -> Maybe Int-
No nulls
-
No exceptions
Make illegal states
Unrepresentable
data Status = Verified | UnverifiedUse types for
State Machines
data ShoppingCart = Empty | Active [Item] | Paid [Item]Beautiful clean
internal model
Dirty unclean outside world
The Great Gate
Monoids, Functors, Applicatives and Monads
Are all different algebras
They are ideas about computation
Not just specific to Haskell
Functions of type
a -> b
Transform values of type a to values of type b
(+1) :: Int -> Intshow :: Int -> String( Increments a number by 1 )
( Returns the string representation of a number )
But what if a value is in some kind of container?
eg a maybe
Maybe
data Maybe a = Nothing | Just a2 -- a value
Just 2 -- a value with context.
When a value is wrapped in a context (eg a list, or maybe)
You can't apply a normal function to it.
fmap
fmap knows how to apply a function to a value in a context
fmap (+3) (Just 2)
Just 5But how does fmap do this wizardry?
Functor is a typeclass
A typeclass is a sort of interface that defines some behavior.
If a type is part of a typeclass,
that means it implements the behaviour the typeclass describes
class Functor f where
fmap :: (a -> b) -> f a -> f bTo make data type f a functor
You'll need to implement this function for your data type
The map function
map :: (a -> b) -> [a] -> [b]map :: (Int -> String) -> [Int] -> [String]map show [1, 2, 3, 4] ["1", "2", "3", "4"]map (+1) [1, 2, 3, 4][2, 3, 4, 5]If something is a functor
then there exists a function called fmap that will lift transformations from
a -> b
to
f a -> f b
Examples
fmap specialized to lists has the type:
(a -> b) -> ([a] -> [b])fmap specialized to Maybe has the type:
(a -> b) -> (Maybe a -> Maybe b)We can also have containers with functions in them
Subtitle
Values
2
2 (+1) = 3
Context
Just 1
data Maybe a = Nothing | Just aHaskell
By ..
