Reduce code size with unboxed unary tuples

[treeowl]

Experimentally make most strict and lazy functions share code
using unboxed unary tuples. I fear we may find this too expensive,
but it's an idea. Needs heavy benchmarking.

Addresses #64

[treeowl]

This version has a potential efficiency problem for strict operations. If the passed function doesn't inline, we'll actually build a closure for the function with the type we need. That's not great for insertWith, where we don't have a lot of work over which to amortize the extra cost of allocating the closure. But it's really not good for something like unionWith or insertWith, where we'll pay for the extra indirection every time we need to combine elements.

I realized this evening that if we want to take a walk on the dangerous side, we can probably do it with unsafeCoerce. If we take a function of type a -> a -> a and unsafeCoerce it to a function of type a -> a -> (# a #), what happens? When we case match on the result,

case f a b of
  (# c #) -> ...

GHC will "run" f a b. With a real function of type a -> a -> (# a #), that could produce a thunk. f doesn't really have that type, so running it will produce a value. When we actually use the value, GHC will (unnecessarily) force it again, but that doesn't seem like too big a deal.

The big problem, of course, is that the dangerous version is not remotely supported; if it breaks, we get to keep both pieces.

[sjakobi]

I'll mark this as a draft, since it's apparently still WIP.