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

• - non-delayed integration (using the function's value at the current -- time) ndIntegral :: VectorSpace a s => SF a a ndIntegral = ( _ 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.