text: The AFRP core.
  ToDo:
  * Check embedSynch for space leaks. It might be a good idea to force
  dropped frames.
  * The internal streamToSignal is interesting, and a version somehow
  accepting a time stamped stream/assuming equidistant samples, possibly
  with an interpolation function, might be even more interesting. Perhaps
  consider a version that applies cycle to the supplied list? Note that
  there is a relation to embedSynch since a partial application of
  embedSynch to identity would yield something similar. Or it is
  in some sense the inverse of embed.
  * It seems the use of VectorSpace-based integrals causes more ambiguity
  problems than before. Investigate (comments in AFRPTest.hs).
  * Maybe now, after, repeatedly should return ().
  There could be a bunch of utilities nowTag, afterTag, repeatedlyTag,
  and edgeTag. Decide based on API consistency. E.g. edge already
  returns ().
  * Reconsider the semantics of edgeBy. Does not disallow an edge
  condition that persists between consecutive samples. OTOH, consider
  a signal that alternates between two discrete values (True, False, say).
  Surely we could then see edges on every sample. It's not really for us
  to say whether the edge detecting function does a good job or not?
  * We should probably introduce a type synonym Frequency here.
  It might be most natural to give some parameters in terms of frequency
  (like for repeatedly and occasionally). On the other hand, there
  is after, and it would be good if after and repeatedly are
  mutually consitent, if repeatedly and occsaionally are consitent,
  and if the user knows that Time is the only dimension he or she needs
  to worry about.
  * Here's an argument for why now, after, etc. should return ().
  The event value has to be a static entity anyway in these cases. So,
  if we need them to something DYNAMIC, then the extra argument is useless.
  Or if we don't care. If it is decided to change the interface in that
  way, I guess we could also change Time to Frequency where that makes
  sense. On the other hand, what's the point of now always returning
  ()? Would one not usually want to say what to return? If yes, then
  There is something to be said for making after consitent with now.
  After all, we should have now = after 0.
  * Maybe reactimate should be parameterized on the monad type?
  * Revisit the reactimate interfaces along with embedding.
  * Revisit integration and differentiation. Valery suggests:
  integral :: VectorSpace a s => SF a a
  integral = ( a _ dt v -> v ^+^ realToFrac dt *^ a) iterFrom
  zeroVector
  derivative :: VectorSpace a s => SF a a
  derivative = ( a a' dt _ -> (a' ^-^ a) ^/ realToFrac dt) iterFrom
  zeroVector
  iterFrom :: (a -> a -> DTime -> b -> b) -> b -> SF a b
  f iterFrom b = SF (iterAux b) where
  iterAux b a = (SFTIVar ( dt a' -> iterAux (f a a' dt b) a'), b)
  See also the original e-mail discussion.