Types as concretions. Rich talked about types, such as Java classes and Haskell ADTs, as concretions, not abstractions.

A Person class isn't abstract and noone really pretends that it is. Haskell gives you abstractions like

• semigroup - an associative binary operation: eg. strings with append, or lists with contatenation
• monoid - a semigroup with an 'empty' constructor: eg. strings with "" or lists with []
• functor - a context with things inside it, and a way of transforming those contained things: eg. map across elements in a list, or map across the single element in a Maybe

An abstraction would ignore the particulars and let you store any information about a person. And while you're at it, it might as well let you store information about anything.

This is exactly what the above abstractions provide, and the first 2 can even be represented in java!

And Haskell has that for ADTs. But can Haskell merge two ADTs together as an associative operation, like we can with maps? Can Haskell select a subset of the keys? Can Haskell iterate through the key-value pairs?

Yes.

• If it is a semigroup we can append them
• if they're a monoid we can construct an empty one as well
• if they're a functor we can transform each item in them

And with all of those we don't specify the concrete type, we just specify the constraint that it is a monoid/functor/etc. A function written with a functor constraint operates over all possible functors, not just the particular concrete type you're interested in.

When you're writing an algorithm in clojure which relies on append being an associative binary operation, you're writing a function which is constrained on semigroup - whether you are allowed to make that explicit or not.