`Preface_specs`

Set of interfaces describing all the abstractions available in Preface. For a detailed description of the module breakdown logic, go to the homepage.

`module Semigroup : sig ... end`

A `Semigroup`

is a type `t`

which provides a binary associative operation `combine`

which lets you combine any two values of `t`

into one.

`module Monoid : sig ... end`

A `Monoid`

is a type `t`

which provides a binary associative operation `combine`

and a neutral element (`neutral`

). In other words, a `Monoid`

is a `Semigroup`

with a neutral element.

`module Invariant : sig ... end`

`Invariant`

is an "Invariant Functor". Every `Functor`

and `Contravariant`

is an Invariant Functor.

`module Functor : sig ... end`

A `Functor`

represents a type that can be mapped over. So we can go from `'a t`

to `'b t`

using a function from `'a`

to `'b`

. Mapping preserve the structure of the input.

`module Alt : sig ... end`

`module Apply : sig ... end`

An `Apply`

is a functor with lifting and sequencing capabilities. `Apply`

is more general (and by extension weaker) than a `Applicative`

. An `Apply`

is also a `Functor`

.

`module Applicative : sig ... end`

`module Alternative : sig ... end`

`Alternative`

is a kind of `Monoid`

on `Applicative`

. An `Alternative`

is formally an `Applicative`

with `neutral`

and `combine`

. So an `Alternative`

is also an `Applicative`

(and an `Alt`

which is also a `Functor`

).

`module Selective : sig ... end`

A `Selective`

(applicative functor) allows to declare effects statically and select which execute dynamically. It is an algebraic structure between `Applicative`

and `Monad`

. A `Selective`

is also an `Applicative`

.

`module Bind : sig ... end`

A `Monad`

allow to sequences operations that are dependent from one to another, in contrast to `Applicative`

, which executes a series of independent actions.

`module Monad : sig ... end`

A `Monad`

allow to sequences operations that are dependent from one to another, in contrast to `Applicative`

, which executes a series of independent actions.

`module Monad_plus : sig ... end`

`module Foldable : sig ... end`

A `Foldable`

is a data structure which can be fold. In other word, reduced to a summary value one element at a time

`module Traversable : sig ... end`

A `Traversable`

is a data structure that can be traversed from left to right, performing an action on each element.

`module Contravariant : sig ... end`

`Contravariant`

is a "Contravariant functor". In other word, `Contravariant`

is the dual of a `Functor`

.

`module Divisible : sig ... end`

`Divisible`

is a "Contravariant Applicative Functor", in other word, `Divisible`

is the dual of an `Applicative`

`module Decidable : sig ... end`

`Decidable`

is a "Contravariant Alternative".

`module Bifunctor : sig ... end`

A `Bifunctor`

is a type constructor that takes two type arguments and is a `Functor`

(Covariant) in both arguments.

`module Profunctor : sig ... end`

A `Profunctor`

is a type constructor that takes two type arguments and is a `Contravariant`

`Functor`

as first argument and a `covariant`

`Functor`

as second argument.

`module Strong : sig ... end`

`Strong`

is a `Profunctor`

working on product types.

`module Choice : sig ... end`

`Choice`

is a `Profunctor`

working on sum types (via `Either`

).

`module Closed : sig ... end`

`Closed`

is a `Profunctor`

working on exponential types (function).

`module Semigroupoid : sig ... end`

A `Semigroupoid`

is `Category`

without the identity.

`module Category : sig ... end`

A `Category`

is a `Semigroupoid`

with an identity at each object.

`module Arrow : sig ... end`

An `Arrow`

is an abstract view of computation sitting between `Applicative`

and `Monad`

. `Arrow`

is built on the top of `Category`

and `Strong`

. So an `Arrow`

is also a `Category`

.

`module Arrow_zero : sig ... end`

`module Arrow_alt : sig ... end`

`module Arrow_plus : sig ... end`

An `Arrow_plus`

is the conjonction of an `Arrow_zero`

and `Arrow_alt`

. An `Arrow_plus`

is a kind of `Monoid`

in the arrow hierarchy. And it also an `Arrow_alt`

and an `Arrow_zero`

(which is also a `Arrow`

).

`module Arrow_choice : sig ... end`

`module Arrow_apply : sig ... end`

`module Reader : sig ... end`

A `Reader monad`

parametrized over an inner `Monad`

and an environment. `Reader`

is a *monad transformer*.

`module Writer : sig ... end`

`module State : sig ... end`

A `State monad`

parametrized over an inner `Monad`

and a state (which is an arbitrary type). `State`

is a *monad transformer*.

`module Store : sig ... end`

A `Store comonad`

parametrized over an inner `Comonad`

and a store (which is an arbitrary type). `Store`

is a *comonad transformer*. `Store`

is `Costate`

(the dual of `State`

).

`module Env : sig ... end`

An `Env comonad`

parametrized over an inner `Comonad`

and an env (which is an arbitrary type). `Env`

is a *comonad transformer*. `Env`

is `Coreader`

(the dual of `Reader`

).

`module Traced : sig ... end`

A `Traced comonad`

parametrized over an inner `Comonad`

and a tape (which is an arbitrary type). `Traced`

is a *comonad transformer*. `Traced`

is `Cowriter`

(the dual of `Writer`

).

`module Free_applicative : sig ... end`

A `Free applicative`

allows you to build an `Preface_specs.Applicative`

from a given `Preface_specs.Functor`

.

`module Free_selective : sig ... end`

A `Free selective`

allows you to build a *rigid* `Preface_specs.Selective`

from a given `Preface_specs.Functor`

.

`module Freer_selective : sig ... end`

A `Freer selective`

allows you to build a *rigid* `Preface_specs.Selective`

from a given arbitrary type.

`module Free_monad : sig ... end`

A `Free monad`

allows you to build a `Preface_specs.Monad`

from a given `Preface_specs.Functor`

.

`module Freer_monad : sig ... end`

A `Freer monad`

allows you to build a `Preface_specs.Monad`

from an arbitrary type (with one type parameter). It offers the same capabilities as a `Preface_specs.Free_monad`

but benefits from a lighter execution cost.

As each module exposes all the components of an abstraction, here is a list of shortcuts to directly denote the full API of an abstraction by using its name in upper case.

`module type SEMIGROUP = Semigroup.API`

`module type MONOID = Monoid.API`

`module type FUNCTOR = Functor.API`

`module type BIFUNCTOR = Bifunctor.API`

`module type PROFUNCTOR = Profunctor.API`

`module type STRONG = Strong.API`

`module type CHOICE = Choice.API`

`module type CLOSED = Closed.API`

`module type APPLY = Apply.API`

`module type APPLICATIVE = Applicative.API`

`module type ALT = Alt.API`

`module type ALTERNATIVE = Alternative.API`

`module type SELECTIVE = Selective.API`

`module type BIND = Bind.API`

`module type MONAD = Monad.API`

`module type MONAD_PLUS = Monad_plus.API`

`module type COMONAD = Comonad.API`

`module type FOLDABLE = Foldable.API`

`module type TRAVERSABLE = Traversable.API`

`module type FREE_APPLICATIVE = Free_applicative.API`

`module type FREE_SELECTIVE = Free_selective.API`

`module type FREER_SELECTIVE = Freer_selective.API`

`module type FREE_MONAD = Free_monad.API`

`module type FREER_MONAD = Freer_monad.API`

`module type INVARIANT = Invariant.API`

`module type CONTRAVARIANT = Contravariant.API`

`module type DIVISIBLE = Divisible.API`

`module type SEMIGROUPOID = Semigroupoid.API`

`module type DECIDABLE = Decidable.API`

`module type CATEGORY = Category.API`

`module type ARROW = Arrow.API`

`module type ARROW_ZERO = Arrow_zero.API`

`module type ARROW_ALT = Arrow_alt.API`

`module type ARROW_PLUS = Arrow_plus.API`

`module type ARROW_CHOICE = Arrow_choice.API`

`module type ARROW_APPLY = Arrow_apply.API`

`module type READER = Reader.API`

`module type WRITER = Writer.API`

`module type STATE = State.API`

`module type STORE = Store.API`

`module type ENV = Env.API`

`module type TRACED = Traced.API`

Sometimes, in order to construct an abstraction, it is only necessary to give it a type (For example, `Freer_monad`

).

`module Types : sig ... end`

Signatures representing types. Mainly used as a functor parameter