The fact that `Applicative`

type class allows one to express simple parsers in a variable-less combinatorial style is well appreciated among Haskell programmers for its conceptual simplicity, ease of use, and usefulness for semi-automated code generation (metaprogramming).

We notice that such `Applicative`

computations can be interpreted as providing a *mechanism* to construct a data type with "ports" "pluggable" by subcomputations. We observe that it is this property that makes them so much more convenient in practice than the usual way of building the same computations using conventional composition. We distill this observation into a more general algebraic structure of (and/or technique for expressing) "`Applicative`

-like" computations and demonstrate several other instances of this structure.

Our interest in all of this comes from the fact that the aforementioned instances allow us to express arbitrary transformations between simple data types of a single constructor (similarly to how `Applicative`

parsing allows to transform from streams of `Char`

s to such data types) using a style that closely follows conventional `Applicative`

computations, thus greatly simplifying (if not completely automating away) a lot of boiler-plate code present in many functional programs.

Changelog:

- Version 1.1: fixed a couple of tiny typos
- Version 1: initial

Downloads:

See also: