With unfold you can easily generate algebraic data structures from other data. The following example shows how to generate a decreasing list of numbers.

Unfolds do not use the actual constructors, but stand-ins that perform recursion at the right places. In this example c.Cons recursively calls the unfold function for it's second argument, and then calls the Cons constructor with the result. Let's try it out:

Fold is the reverse of unfold. It destructs data into a return value. Here is an example that multiplies a list of numbers.

You can understand a fold as replacing the constructors with the given functions. Let's test this code:

You may have noticed that with combining prod and counter we have created the factorial function. However, it is quite wasteful as it builds up a list which it then destroys again. But this adt library has a solution for that, it allows you to merge functions that are defined over the same data type:

Now we have a factorial function that was neatly defined using the structure of List, but no list is created. c.Cons instead of calling the Cons constructor, now directly calls the Cons function from prod.

With map you provide a function for each type parameter. Here are 2 examples using the XML data types:

The first adds a prefix to each name, leaving values alone (using the id function), and the second strips whitespace from values, leaving names alone. For a more complete example, let's write a serialization function for the XML data:

Now if we wanted to add prefixes, normalize space and then serialize the xml, we could write:

But then we would traverse the data structure 3 times. We would like to merge these functions so that the data structure is traversed only once. (When this is done in the compiler it is called deforestation or fusion.)

In general you can merge one fold, one unfold and any number of maps, as long as they are defined on the same data type.

All these unfolds, folds, maps and any merged combination of them are special cases of transformers. A transformer declaration has 4 parts: a generator (unfold), transformation of constructors (fold), transformation of type parameters (map) and transformation of non-algebraic types. The last tree are best explained with an example:

Then the following are equivalent:

Ie. each constructor is replaced with f, each value in a type parameter position is wrapped with g, and other (non-algebraic) values are wrapped with h.

Derived properties are like derived classes in Haskell, they apply to every algebraic data object that is created.

The adt library already contains clone, source, equals, size and items. Some examples for the previously defined xml object:

But you can also add your own derived properties. Here is how you would define items:

To see if even advanced Haskell code would work in JavaScript, I took a shot at Data types à la carte by Wouter Swierstra. It addresses the Expression Problem:

The goal is to define a data type by cases, where one can add new cases to the data type and new functions over the data type, without recompiling existing code, and while retaining static type safety.

Of course, that last property is lost in the translation to JavaScript, but otherwise this code works.

First the initial data type, expressions with values and addition.

Next, we create an evaluation function with fold.

Now we can add multiplication to the expression type.

And finally we add a render function.