3.2 The Base Classes🔗ℹ

3.2.1 Applicative Functor🔗ℹ

A functor with application, providing operations to

• embed pure expressions (pure), and

• sequence computations and combine their results (<*> and liftA2).

• <*> = (>> liftA2 id)

• (liftA2 f x y) = (<*> (<$> f x) y)

Further, any definition must satisfy the following:

identity

(<*> (pure id) v) = v

composition

(<*> (<*> (<*> (pure ..) u) v) w) = (<*> u (<*> v w))

homomorphism

(<*> (pure f) (pure x)) = (pure (f x))

interchange

(<*> u (pure y)) = (<*> (pure (>> $ y)) u)

The other members have the following default definitions, which may be overridden with equivalent specialized implementations:

• (*> u v) = (<*> (<$ id u) v)

• (<* u v) = (liftA2 const u v)

As a consequence of these laws, the functor instance for f will satisfy

• (fmap f x) = (<*> (pure f) x)

It may be useful to note that supposing, for all x and y,

(>> p (q x y)) = (.. (>> f x) (>> g y))

it follows from the above that

(>> liftA2 p (liftA2 q u v)) = (.. (>> liftA2 f u) (>> liftA2 g v))

If f is also a Monad, it should satisfy

• pure = return

• <*> = ap

• *> = >>M

(which implies that pure and <*> satisfy the applicative functor laws).

3.2.1.1 Members🔗ℹ

Minimal instance: pure, (<*> or liftA2)

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This is essentially the same as (>> liftA2 (flip const)), but if the functor instance has an optimized <$, it may be better to use that instead.

3.2.1.2 Helpers🔗ℹ

Eager applicative chains get noisy as they grow because Racket functions must be curried explicitly.

The function (in this case, +) must be wrapped in one >>* for each applicative argument or <*> will fail.

This variant wraps the function with >>*. Unless lazy semantics are desired, make the final operator in the chain eager (e.g., <*>) to evaluate the whole chain by force.

3.2.2 Functor🔗ℹ

The functor class is used for types that can be mapped over.

• (>> fmap id) = id

• (>> fmap (.. f g)) = (.. (>> fmap f) (>> fmap g))

3.2.2.1 Members🔗ℹ

Minimal instance: fmap

3.2.2.2 Helpers🔗ℹ

The name of this operator is an allusion to $. Whereas $ is function application, <$> is function application lifted over a functor.

Examples:

Convert from a Maybe Int to a Maybe String using ~a:

> (with-instance maybe-functor (<$> ~a Nothing))

Nothing

> (with-instance maybe-functor (<$> ~a (Just 3)))

(Just "3")

Double each element of a list:

> (with-instance list-functor (<$> (>> * 2) '(1 2 3)))

'(2 4 6)

3.2.3 Monad🔗ℹ

Basic operations on monads, and a generic do-notation.

• (>>= (return a) k) = (k a)

• (>>= m return) = m

• (>>= m (φ x (>>= (k x) h))) = (>>= (>>= m k) h)

Monads and Applicatives should relate as follows:

• pure = return

• <*> = ap

The above laws imply:

• (fmap f xs) = (>>= xs (.. return f))

• >> = *>

and that pure and <*> satisfy the applicative functor laws.

3.2.3.1 Members🔗ℹ

Minimal instance: >>=

3.2.3.2 Helpers🔗ℹ

3.2.3.3 Do-Notations🔗ℹ

do composes a seies of do-exprs with a final expr to determine its result.

do~ is similar, except it expects each do-expr to be warpped in a thunk, and it produces a thunk.

A do-expr has one of the following forms:

formals <- monad-expr

Evaluates the monad-expr and binds the monad’s contents according to formals.

Examples:

> (with-instance list-monad     (do (x) <- '(1 2 3 4)         (return (add1 x))))

'(2 3 4 5)

let id expr

Evaluates the expr and binds the result to id.

Example:

> (with-instance truthy-monad     ((do~ let `(a . ,b) '(a 1 2 3)           (return b))))

'(1 2 3)

let-values formals expr

Evaluates the expr and binds the result according to formals.

Example:

monad-expr

Evaluates the monad-expr and discards the result.

Examples:

> (with-instance box-monad (do #&1 (return 2)))

'#&2

Examples:

3.2.4 Monoid🔗ℹ

The class of monoids (types with an associative binary operation that has an identity).

• (<> x mempty) = x

• (<> mempty x) = x

• (<> x (<> y z)) = (<> (<> x y) z) (Semigroup law)

• mconcat = (foldr <> mempty)

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers.

3.2.4.1 Members🔗ℹ

NOTE: This method is redundant and has the default implementation mappend = <>.

For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

3.2.5 Semigroup🔗ℹ

The class of semigroups (types with an associative binary operation).

• (<> x (<> y z)) = (<> (<> x y) z)

3.2.5.1 Members🔗ℹ

The default definition should be sufficient, but this can be overridden for efficiency.

Given that this works on a semigroup it is allowed to fail if you request 0 or fewer repetitions, and the default definition wll do so.

3.2.5.2 Helpers🔗ℹ