A functor is a mapping between two categories.
Let \(\C\) and \(\D\) be two categories.
A functor \(\F\) from \(\C\) to \(\D\):
Associate objects: \(A\in\ob{\C}\) to \(\F(A) \in\ob{\D}\)
Associate morphisms: \(f:A\to B\) to \(\F(f) : \F(A) \to \F(B)\)
such that
\( \F (\id_X) = \id_{\F(X)} \),
\( \F (g \circ_\C f) = \F(g) \circ_\D \F(f) \)
Functor Example (ob → ob)
Functor Example (hom → hom)
Functor Example
Plan
Why?
What?
How?
\(\Hask\) category
Functors
Monads
Arrows
κατα-morphisms
Hask
Category \(\Hask\):
\(ob(\Hask) = \) Haskell types
\(hom(\Hask) = \) Haskell functions
∘ = (.) Haskell function composition
Forget glitches because of undefined.
Haskell Functors
Haskell Functors are from Hask to Hask; \(F:\C→\C\) are called endofunctors.
Haskell Functors are Object of Hask.
Notation:
F <type> → <type> denoted F :: * -> *
F <function> → <function>✗
fmap: <function> → <function>✓ choose F with polymorphism.
Properties fmap must obey for F to be a real functor:
fmap id = id and fmap f.g = fmap f . fmap g
Haskell Functors Example: Maybe
data Maybe a = Just a | Nothing
instance Functor Maybe where
fmap :: (a -> b) -> (Maybe a -> Maybe b)
fmap f (Just a) = f a
fmap f Nothing = Nothing
fmap (+1) (Just 1) == 2
fmap (+1) Nothing == Nothing
fmap head (Just [1,2,3]) == Just 1
Haskell Functors Example: List
instance Functor ([]) where
fmap :: (a -> b) -> [a] -> [b]
fmap = map
fmap (+1) [1,2,3] == [2,3,4]
fmap (+1) [] == []
fmap head [[1,2,3],[4,5,6]] == [1,4]
String like type
data F a = Cons Char a | Nil
-- examples :
-- Cons 'c' 32 :: F Int
-- Cons 'c' (\x -> x*x) :: F (Int -> Int)
-- Cons 'c' (Cons 'a' (\x -> x*x)) :: F (F (Int -> Int))
-- Cons 'c' (Cons 'c' Nil) :: F (F (F))
-- note String is the fixed point of F: F(F(F(...)))
instance Functor F where
fmap :: (a -> b) -> [a] -> [b]
fmap f (Cons c x) = Cons c (f x)
fmap f Nil = Nil
fmap (+1) (Cons 'c' 3) == Cons 'c' 4
fmap (+1) Nil == Nil
fmap head (Cons 'c' [1,2,3])== Cons 'c' 1
Functor as boxes
Haskell functor can be seen as boxes containing all Haskell types and functions.
Haskell types is fractal:
