ReadMe.md

Overview

There are type classes that control the flow of the program (e.g. whether the program should do X and then Y or should do X and Y at the same time).

Functor, Apply, and Bind Type Classes Explained in Pictures

We've linked to an article below that explains these abstract notions in a clear manner using pictures and the Maybe a data structure. However, since these concepts are explained in Haskell, which uses different terminology than Purescript, use the following table to map Haskell terminology to Purescript terminology:

Haskell Terminology	Purescript Terminology
fmap (function)	map (function)
Applicative (type class)	Apply (type class)
Array/[] (syntax sugar for List a)	List a
map (Array function)	see the implementation in Purescript
IO ()	Effect Unit, which will be explained/used in a later part of this folder

Here's the link: Functors, Applicatives, and Monads in Pictures

Lists' Map Function in Purescript

Here's the map List function implemented in Purescript:

data List a = Nil | Cons a (List a)

instance Functor List where
  map :: forall a b. (a -> b) -> List a -> List b
  map f Nil = Nil
  map f (Cons head tail) = Cons (f head) (map f tail)

Functor, Apply, Applicative, Bind, Monad

These will be covered at a slower and clearer pace in the upcoming files. This is just an overview of them.

Typeclass	"Plain English"	Function	Infix	Laws	Usage
Functor	Mappable	map :: forall a b. (a -> b) -> f a -> f b	<$> (Left 4)	identity: map (\x -> x) fa == fa composition: map (f <<< g) = map f <<< map g	Change a value, a, that's currently stored in some box-like type, f, using a function, (a -> b)
Apply	Boxed Mappable	apply :: forall a b. f (a -> b) -> f a -> f b	<*> (Left 4)	Associative composition: (<<<) <$> f <*> g <*> h == f <*> (g <*> h)	Same as Functor except the function is now inside of the same box-like type.
Applicative	Liftable Parallel Computation	pure :: forall a. a -> f a		identity: (pure (\x -> x) <*> v == v) composition: pure (<<<) <*> f <*> g <*> h == f <*> (g <*> h) Homomorphism: (pure f) <*> (pure x) == pure (f x) interchange: u <*> (pure y) == (pure (_ $ y)) <*> u	Put a value into a box Run code in parallel
Bind	Sequential Computation	bind :: forall m a b. m a -> (a -> m b) -> m b	>>= (Left 1)	Associativity: (x >>= f) >>= g == x >>= (\x' -> f x' >>= g)	Given an value of a box-like type, m, that contains a value, a, extract the a from m, and create a new m value that stores a new value, b. Take f a and compute it via bind/>>= to produce a value, a. Then, use a to describe (but not run) a new computation, m b. When m b is computed (via a later bind/>>=), it will return b.
Monad	FP Program			Left Identity: pure x >>= f = f x Right Identity: x >>= pure = x Applicative Superclass: apply = ap	The data structure used to run FP programs by executing code line-by-line, function-by-function, etc.

Simplest Monad Implementation

data Box a = Box a

instance f :: Functor Box where
  map        f  (Box a) = Box (f a)

instance a1 :: Apply Box where
  apply (Box f) (Box a) = Box (f a)

instance b :: Bind Box where
  bind  (Box a) f       = f a

instance a2 :: Applicative Box where
  pure a = Box a

instance m :: Monad Box

Function Reduction

In these files, we will "evaluate" functions by using graph reductions: replacing the left-hand side (LHS) of the = sign (the function's call signature) with the right-hand side (RHS) of the = sign (the function's implementation / body). In other words...

someFunction arg1 arg2 arg3 = bodyOfFunction
| call signature (LHS)    | = | body (RHS) |