What exactly does your code do when you are trying to sample the far future? I don’t understand where the magic future function comes from that can handle this case, but I assume this is what the (imperative?) framework should provide. And again, if we never want to sample with a future time, how is this different from an IORef after all and why is it better?

Gergely

Thanks for the great suggestion! It also feeds very nicely into relative time:

order :: Future a -> Future a -> Future (a, Future a)
order (t,a) (t',b)
 | t <= t'   = (t,  (a, (t'-t, b)))
 | otherwise = (t', (b, (t-t', a)))

Then use this order function to define mappend on events (temporal interleaving).

order :: Future a -> Future a -> Future (a, Future a)
order (t,a) (t',b)
 | t <= t'   = (t,  (a, (t', b)))
 | otherwise = (t', (b, (t,  a)))

So that the rest of the reactive code can be independent of your representation.

Oh, and this looks like a nice lead, by the way.

I think what makes these futures be absolute time is the use of the Max monoid. Switching to the Sum monoid gives relative time. Moreover, the definition of until needs some tweaking.

Absolute version:

(b `until` Future (t',b')) `at` t = b'' `at` t
 where
   b'' = if t <= t' then b else b'

The relative version has only a small change:

(b `until` Future (t',b')) `at` t = b'' `at` t
 where
   b'' = if t <= t' then b else pad t' b'

where the pad function prepends a segment of ⊥ to a behavior (or any Segment type). (For lists, pad n == (repeat n undefined ++).)

Equivalently,

(b `until` Future (t',b')) `at` t
  | t <= t'   = b  `at` t
  | otherwise = b' `at` (t - t')

Using the ideas in Sequences, streams, and segments and in Sequences, segments, and signals, we get a much more elegant definition:

b `until` Future (t',b') = take t' b `mappend` b'

This formulation is what inspired those two blog posts and my renewed interest in relative time FRP.

With function futures or caching futures, until would look like the following for absolute time:

(b `until` u) `at` t = b'' `at` t
 where
   b'' = case tryFuture u t of
           Nothing              -> b
           Just (Future (_,b')) -> b'

For relative time,

(b `until` u) `at` t = b'' `at` t
 where
   b'' = case tryFuture u t of
           Nothing               -> b
           Just (Future (t',b')) -> pad t' b'

I don’t know how to extend the more elegant take/mappend version to use tryFuture.

Also, I understand why it’s okay to use unsafePerformIO here but it still makes me a little squeamish. I don’t trust myself with that abstraction-breaking hammer yet.