# A cheat-sheet for Haskell & PureScript typeclasses

One-page overview of a bunch of different Haskell & PureScript typeclasses. Starting with the PureScript Class Hierarchy diagram, and similar on the Haskell Typeclassopedia. Very much a work in progress: info and terminology may be completely wrong!

## Functor

Map a value inside a context to a new value:

``````class Functor f where
fmap :: (a -> b) -> f a -> f b
``````

## Applicative

With a function (or, more intuitively, a partial computation) inside a context, map a value also inside the same context:

``````class Functor f => Applicative f where
(<*>) :: f (a -> b) -> f a -> f b
``````

Also provide a way to lift a value into a context:

``````  pure  :: a -> f a
``````

### Usage

For instance, how could we sum `Just 2` and `Just 3`? 1

``````> :t fmap (+)
fmap (+) :: (Functor f, Num a) => f a -> f (a -> a)
> :t fmap (+) (Just 2)
fmap (+) (Just 2) :: Num a => Maybe (a -> a)
``````

Ah, now we can use `<*>`:

``````fmap (+) (Just 2) <*> (Just 3)
``````

So when you have a function `a -> b -> c`, partially apply it, and lift into the functor, you end up with `f (b -> c)`, then to apply it to a second parameter of type `b`, you use `<*>`, and end up with `f c`. Thus:

`<*>` is just function application within a computational context.2

Use the result of a previous computation as input into another computation, i.e. sequence computations.

One consequence is that a sequence may not preserve the structure of an input. An example: when under `Maybe`, functors and applicatives can’t change the result from `Just a` to `Nothing`, since none of the parameters return `f b`, they only return `b`. You need to “upgrade” to a monad to be able to use a function like ```a -> m b```.

## Semigroup

Set `S` with a binary operation `<>` that combines two elements of `S` into another element of `S`:

``````class Semigroup a where
(<>) :: a -> a -> a
``````

`<>` must be associative.

## Monoid

Extension of a Semigroup with an identity element `i`, such that ```s <> i == i <> s == s```.

## Semigroupoid

Set of objects with composable morphisms. E.g. like a category, but without requiring an identity element.

``````class Semigroupoid a where
compose :: forall b c d. a c d -> a b c -> a b d
``````

`(->)` is a semigroupoid, with `(.)` as `compose`: ```(.) :: (b -> c) -> (a -> b) -> (a -> c)```.

## Category

Semigroupoid with an identity element.

To be less facetious, a category is a set of objects, composable morphisms, and an identity element, such that `id <<< p = p <<< id = p`

## Group

A Group is a Monoid with inverses. Numbers form a group with `+` as the inverse of a value `a` is `-a`:

``````a + -a = zero
``````

## Semiring

types that support addition and multiplication.

## Ring

Semiring that also supports subtraction.

## Arrow

a value of type `b `arr` c` can be thought of as a computation which takes values of type `b` as input, and produces values of type `c` as output.