Though it does not often get mentioned in the Haskell community, simply
bumping to a new version of GHC can drastically improve the performance of your
code. Here, I have several examples from my
`fast-arithmetic`

package, which will hopefully give an idea of just how much work has gone into
optimizing code produced by GHC.

Below, I have collected several examples of "uncanny" Haskell. These are things
that may be surprising to those who have learned the language merely by *doing*.

You may have seen my post on co-(Elgot algebras),
in which I mentioned I had been using some exotic recursion schemes for my
`gmpint`

package. I came across a similar example, this time for Mendler-style
recursion schemes. To my knowledge, it is the only published example of
a Mendler-style catamorphism.

I've been looking for an example of co-(Elgot algebra)s for quite some time, and
I came across a surprisingly nice example while working on my
`gmpint`

package.

As many of you will know, Haskell is a *non-strict* language, with
non-strictness implemented via the more familiar *laziness*. Laziness has come
to define Haskell, and here I would like give an expansive view of why.