This is very cool.

(Thanks to David Nolen, who pointed out errors in the original.)

I hadn't realized that the standard higher order sequence functions compose in a manner that requires quite a bit of run-time machinery. For example nested map calls will cause a separate lazy sequence to be instantiated at each level of nesting, with each level "pulling" results from the next innermost as needed. The function calls are thus temporally interleaved, but the functions are not actually composed. We can see this happening by adding some printlns to some unary functions and then running a nested …

Here's a brief presentation on using closures and futures to do background processing:

And here's the code on github.

There's a conspiracy to prevent you from understanding functors, and the here are some of the tools used to keep you in the dark:

1. In explanations about functional programming, authors blithely use f to mean either a function or an object for which there's a functor, e.g.

  f      :: (a -> b -> c)
  fmap   :: Functor f => (d -> e) -> f d -> f e
  fmap f :: Functor f =>             f a -> f (b -> c)    -- Identify d with a, and e with (b -> c)

1. The word functor sometimes means a mapping between categories and other times means an object in a category for which such …

Mr Podsnap was well to do, and stood very high in Mr Podsnap's opinion. Beginning with a good inheritance, he had married a good inheritance, and had thriven exceedingly in the Marine Insurance way, and was quite satisfied. He never could make out why everybody was not quite satisfied, and he felt conscious that he set a brilliant social example in being particularly well satisfied with most things, and, above all other things, with himself.

Thus happily acquainted with his own merit and importance, Mr Podsnap settled that whatever he put behind him he put out of existence. There was …