Principle Guided Development

Stay at the highest possible level of a language.

Layered (hierarchical) DSLs to rise the level of abstraction to actual concepts from the problem domain.

The Lambda Calculus showed us that abstraction and application is enough for everything (but too unrestricted - everything could be applied to everything else, which is wrong).

Every algorithm could be expressed as a flow-chart with just 3 forms

• sequencing
• branching (conditionals, pattern-matching)
• looping (which must be is a recursive call really)

Algebraic data types correspond to so-called abstract universal constrictions

• a product
• a coproduct (or a sum)
• an arrow (a single step or transition)

Once you have these universal basic building blocks you nest them.

This is how one gets arbitrary complex, but fully specified and well-typed abstract structures.

The essence of a Monoid is not an identity element, but the closure property - that the result of the associative binary operation is in the same set (of the same type or kind).

It is due to this property everything composes in principle.

Associativity is also crucial, and an identity is required to do it “right” (the base cases).

Immutable and therefore persistent data does not require locks or any synchronization primitives.

This eliminates the whole classes of subtle bugs at the cost of sub-optimal space requirements and performance.

Abstract interfaces (of ADTs) act as cell membranes.

With them on just puts everything together, like Lego blocks.

The notion for a nested value of being of exactly the same shape.

Suddenly one has a precise language to talk about shapes of values.

Uniformity is a sign of approaching perfection. Partial application is essential.

Type-constructors are just the same notion as data-constructors, but at the type-level.

This is how one uniformly specifies abstract interfaces at the type-level.

To be an X (to be taken as an X) is to implement this and that.

They just have done it right, in the sense of what the Buddha meant by “just right” - nothing to remove, nothing to add.

Partial application of type-constructors is useful.

We still don’t have this in Haskell or Ocaml. Scala 3 is going in this direction.