essence-of-live-coding-frp: Continuous time FRP with eolc

[miguel-negrao]

This PR contains two packages:

• essence-of-live-coding-frp
• essence-of-live-coding-frp-test

essence-of-live-coding-frp is a port of Bearriver for essence-of-live-coding.

Notable changes from Bearriver:

• functions which don't use time are of type Cell m a b, cells which do are of type Cell (ClockInfoT m) a b.
• Event type has been substituted by Maybe.
• Not all Yampa combinators have been ported, notably many switch variants are missing.
• takeWhile and dropWhile implementation was changed, I believe the original ones are buggy. Added tests that check their behaviour.
• Some utility functions which are not present in Bearriver were added. I think of essence-of-live-coding-frp as a package which should have almost everything you need to do FRP programming. Also added a module to automatically uncurry functions and lift them to arrows. Currently the functions added are:

  holdM :: (Monad m, Data a) => Cell m (m a, Maybe a) a`
  arrEM ::
  Monad m =>
  (a -> m b) ->
  Cell m (Maybe a) (Maybe b)
  catchC :: (Monad m, Data e, Finite e) => Cell (ExceptT e m) a b -> (e -> Cell m a b) -> Cell m a b
  throwEC :: Monad m => Cell (ExceptT e m) (Maybe e) ()
  dthrowEC :: (Monad m, Data e) => Cell (ExceptT e m) (Maybe e) ()
  traverseHold :: (Monad m, Data c) => Cell m a c -> c -> Cell m (Maybe a) c

• I changed integral to use the trapezoidal rule instead of the rectangle rule, I think it is more accurate with no drawback. Integral is tested using sine and polynomials.
• I added a function to run ClockInfoT cells which gets the current time using functions from the clock package: runClockInfoC :: MonadIO m => Cell (ClockInfoT m) a b -> Cell m a b.
• I did not touch any code in essence-of-live-coding, but I think that if this is merged then the time related stuff in essence-of-live-coding should be removed. Possibly the function edge might not be needed in eolc, and there is a nameclash with the function once.

Additionally I added a package essence-of-live-coding-frp-test which implements a Linear Temporal Logic approach to testing FRP, porting the code from the yampa-test package. Some of the tests are ported from that package, but many were created by myself. This is a separate package so that other packages can test their own code using this package. This is due to my assumption that you cannot import library code from a test suite of another package, and it also follows the fact that yampa-test is a separate package from Yampa.

• This package also has a demo app with a ball bouncing.
• The LTL implementation is different from yampa-tests. Yampa and MSFs are not exactly compatible, they differ in one important aspect. Yampa streams have a value at time 0, which is separate, while MSFs do not. The way evalT was implemented in yampa-test and the way some functions are defined in Bearriver break the test suite. I reimplemented evalT directly in terms of functions from eolc. I hope/believe that my re-implementation is correct. I tested with some tautologies from LTL and they hold. Obviously a subtle bug might have been missed.
• I find LTL very useful for testing cells. You can easily test some quite complex conditions.
• tests will fail if passed an empty list. Cells must be evaluated using a non-empty list.
• Technically many cells don't need to be tested with a stream with time values (e.g. all the initialization cells). In order to simplify code and not have additional code, I just test them with time values anyway.

Additional info:

• All code in these packages is formatted using ormolu.
• Tests are passing in CI.
• Since almost all code is ported from Bearriver and yampa-test, the copyright is attributed to the original authors of the code (Ivan and you). I hope I did that in the correct way.
• This PR needs the Traversing instance for Cell therefore it goes on top of my PR which introduces that instance.

[turion]

Thanks a lot! This is a huge contribution, I'll have to come back to it later. If you want to speed it up, maybe we can split it into only the FRP part and the test part?

[miguel-negrao]

Thanks a lot! This is a huge contribution, I'll have to come back to it later. If you want to speed it up, maybe we can split it into only the FRP part and the test part?

My pleasure ! :-) Sure, I can do that. So I would do one PR just with the FRP part and another PR (on top of the previous one) with the test stuff ?

Today I was working on my GUI code, and I started wondering if

accum :: (Monad m, Data a) => a -> Cell m (Maybe (a -> a)) (Maybe a)

and similar functions should be generalized to

accum :: (Monad m, Data a, Traversable f) => a -> Cell m (f (a -> a)) (f a)

Such that it can either deal with events in the usual sense (Maybe e), or with lists of events ( [e]). This is relevant for instant when merging events from different sources to be fed into accum. If we want to take just one event then we would use Maybe e, but if want to group possible simultaneous events then we can use [e], and the function accum can deal with both just fine since it is defined as traverse' . accumB. To me it makes more sense to use the general type signature, although for newcomers it will be harder to understand what it does...

[miguel-negrao]

I've split this into two PRs. This one only has the frp library, the test part will go into another PR. Also I've generalized the functions that use traverse' and fixed the documentation issues you mentioned.

[miguel-negrao]

I'm not particularly interested in using or porting Yampa-based code, so I don't feel the need keep the same API. I'm fine with nº2 as long as we have all the required combinators to deal with events and continuous time. Do you have some examples of operators you would want to remove ?