This post is part four of the zip folding series inspired by Max Rabkin’s Beautiful folding post.
I meant to write one little post, but one post turned into four.
When I sense that something can be made simpler/clearer, I can’t leave it be.
- Part One related Max’s data representation of left folds to type class morphisms, a pattern that’s been steering me lately toward natural (inevitable) design of libraries.
- Part Two simplified that representation to help get to the essence of zipping, and in doing so lost the expressiveness necessary to define
- Part Three proved the suitability of the zipping definitions in Part Two.
This post shows how to restore the
Applicative (very useful composition tools) to folds but does so in a way that leaves the zipping functionality untouched.
This new layer is independent of folding and can be layered onto any zippable type.
You can get the code described below.
- 2009-02-15: Simplified
WithCont, collapsing two type parameters into one. Added functor comment about
Continue reading ‘Enhancing a Zip’ »
The post More beautiful fold zipping showed a formulation of left-fold zipping, simplified from the ideas in Max Rabkin’s Beautiful folding. I claimed that the semantic functions are the inevitable (natural) ones in that they preserve zipping stucture.
This post gives the promised proofs.
Continue reading ‘Proofs for left fold zipping’ »
My previous post, Another lovely example of type class morphisms, placed some standard structure around Max Rabkin’s Beautiful folding, using type class morphisms to confirm that the
Applicative instances agreed with their inevitable meanings.
In the process of working out the
Applicative case, I realized the essence of fold zipping was getting a bit obscured.
This post simplifies Max’s
Fold data type a bit and shows how to zip strict left folds in the simpler setting.
You can get the code described here.
- 2008-11-15: I renamed the
Pair' classes to
Continue reading ‘More beautiful fold zipping’ »
I read Max Rabkin’s recent post Beautiful folding with great excitement.
He shows how to make combine multiple folds over the same list into a single pass, which can then drastically reduce memory requirements of a lazy functional program.
Max’s trick is giving folds a data representation and a way to combine representations that corresponds to combining the folds.
Peeking out from behind Max’s definitions is a lovely pattern I’ve been noticing more and more over the last couple of years, namely type class morphisms.
Continue reading ‘Another lovely example of type class morphisms’ »