Specification for interoperability of common algebraic structures in JavaScript
(aka "Algebraic JavaScript Specification")
This project specifies interoperability of common algebraic structures:
An algebra is a set of values, a set of operators that it is closed under and some laws it must obey.
Each Fantasy Land algebra is a separate specification. An algebra may have dependencies on other algebras which must be implemented. An algebra may also state other algebra methods which do not need to be implemented and how they can be derived from new methods.
a.equals(a) === true
(reflexivity)a.equals(b) === b.equals(a)
(symmetry)a.equals(b)
and b.equals(c)
, then a.equals(c)
(transitivity)equals
methodA value which has a Setoid must provide an equals
method. The
equals
method takes one argument:
a.equals(b)
b
must be a value of the same Setoid
b
is not the same Setoid, behaviour of equals
is
unspecified (returning false
is recommended).equals
must return a boolean (true
or false
).
a.concat(b).concat(c)
is equivalent to a.concat(b.concat(c))
(associativity)concat
methodA value which has a Semigroup must provide a concat
method. The
concat
method takes one argument:
s.concat(b)
b
must be a value of the same Semigroup
b
is not the same semigroup, behaviour of concat
is
unspecified.concat
must return a value of the same Semigroup.
A value that implements the Monoid specification must also implement the Semigroup specficiation.
m.concat(m.empty())
is equivalent to m
(right identity)m.empty().concat(m)
is equivalent to m
(left identity)empty
methodA value which has a Monoid must provide an empty
method on itself or
its constructor
object. The empty
method takes no arguments:
m.empty()
m.constructor.empty()
empty
must return a value of the same Monoidu.map(function(a) { return a; }))
is equivalent to u
(identity)u.map(function(x) { return f(g(x)); })
is equivalent to u.map(g).map(f)
(composition)map
methodA value which has a Functor must provide a map
method. The map
method takes one argument:
u.map(f)
f
must be a function,
f
is not a function, the behaviour of map
is
unspecified.f
can return any value.map
must return a value of the same Functor
A value that implements the Apply specification must also implement the Functor specification.
a.map(function(f) { return function(g) { return function(x) { return f(g(x))}; }; }).ap(u).ap(v)
is equivalent to a.ap(u.ap(v))
(composition)ap
methodA value which has an Apply must provide an ap
method. The ap
method takes one argument:
a.ap(b)
a
must be an Apply of a function,
a
does not represent a function, the behaviour of ap
is
unspecified.b
must be an Apply of any value
ap
must apply the function in Apply a
to the value in
Apply b
A value that implements the Applicative specification must also implement the Apply specification.
A value which satisfies the specification of an Applicative does not need to implement:
map
; derivable as function(f) { return this.of(f).ap(this); })}
a.of(function(a) { return a; }).ap(v)
is equivalent to v
(identity)a.of(f).ap(a.of(x))
is equivalent to a.of(f(x))
(homomorphism)u.ap(a.of(y))
is equivalent to a.of(function(f) { return f(y); }).ap(u)
(interchange)of
methodA value which has an Applicative must provide an of
method on itself
or its constructor
object. The of
method takes one argument:
a.of(b)
a.constructor.of(b)
of
must provide a value of the same Applicative
b
should be checkedA value that implements the Chain specification must also implement the Apply specification.
A value which satisfies the specification of a Chain does not need to implement:
ap
; derivable as m.chain(function(f) { return m.map(f); })
m.chain(f).chain(g)
is equivalent to m.chain(function(x) { return f(x).chain(g); })
(associativity)chain
methodA value which has a Chain must provide a chain
method. The chain
method takes one argument:
m.chain(f)
f
must be a function which returns a value
f
is not a function, the behaviour of chain
is
unspecified.f
must return a value of the same Chainchain
must return a value of the same Chain
A value that implements the Monad specification must also implement the Applicative and Chain specifications.
A value which satisfies the specification of a Monad does not need to implement:
ap
; derivable as function(m) { return this.chain(function(f) { return m.map(f); }); }
map
; derivable as function(f) { var m = this; return m.chain(function(a) { return m.of(f(a)); })}
m.of(a).chain(f)
is equivalent to f(a)
(left identity)m.chain(m.of)
is equivalent to m
(right identity)Id
container which implements all methods is provided in
id.js
.