Hello all, I silently updated Elerea [1] to version 2 about half a month ago, which deprecated the old interface in favour of the 'experimental' branch of version 1. The most important change besides this swap is the addition of the clocked variant of the library, which allows the programmer to easily freeze parts of the data-flow network, a feature similar to the clock system of Lucid Synchrone. Also, as of version 2.1.0 (today's update), the parametric variant was revised and simplified, which is reflected in the types of the combinators. Feel free to play with the new features! On to my question. There are three main variants of the library: a basic one and two others that extend it in some way. The extensions are orthogonal -- on the level of denotational semantics they could be represented as monad transformers (at least I strongly believe so, but I haven't verified yet). This means that there should be a fourth variant that combines the two extensions. Also, it might easily be the case that there will be more independent extensions in the future. This smells like a perfect opportunity to turn to aspect oriented programming techniques, but unfortunately I couldn't find a sensible way to exploit the similarities (of which there are plenty!) and share the core logic of the library across these slightly distinct variants. So the question: how does one go about doing aspect oriented programming in Haskell? Any nice examples in the wild? Gergely [1] http://hackage.haskell.org/package/elerea -- http://www.fastmail.fm - Does exactly what it says on the tin