{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE TypeOperators #-}
{-# OPTIONS -fplugin=AsyncRattus.Plugin #-}


-- | Programming with futures.

module AsyncRattus.Future
  ( F(..)
  , SigF(..)
  , mkSigF
  , mkSigF'
  , current
  , future
  , bindF
  , mapF
  , sync
  , syncF
  , switchAwait
  , switch
  , switchS
  , filterMap
  , filterMapAwait
  , filterAwait
  , filter
  , trigger
  , triggerAwait
  , map
  , mapAwait
  , zipWith
  , zipWithAwait
  , fromSig
  , scan
  , scanAwait
  )

where

import AsyncRattus
import AsyncRattus.Signal (Sig(..))
import Prelude hiding (map, filter, zipWith)
import AsyncRattus.Channels

newtype OneShot a = OneShot (F a)

instance Producer (OneShot a) a where
  getCurrent :: OneShot a -> Maybe' a
getCurrent (OneShot (Now a
x)) = a -> Maybe' a
forall a. a -> Maybe' a
Just' a
x
  getCurrent (OneShot (Wait O (F a)
_)) = Maybe' a
forall a. Maybe' a
Nothing'

  getNext :: forall b. OneShot a -> (forall q. Producer q a => O q -> b) -> b
getNext (OneShot (Now a
_)) forall q. Producer q a => O q -> b
cb = O (OneShot a) -> b
forall q. Producer q a => O q -> b
cb (O (OneShot a)
forall a. O a
forall {a}. O (OneShot a)
never :: O (OneShot a))
  getNext (OneShot (Wait O (F a)
x)) forall q. Producer q a => O q -> b
cb = O (OneShot a) -> b
forall q. Producer q a => O q -> b
cb (OneShot a -> O (OneShot a)
forall a. a -> O a
delay (F a -> OneShot a
forall a. F a -> OneShot a
OneShot (O (F a) -> F a
forall a. O a -> a
adv O (F a)
x)))

instance Producer p a => Producer (F p) a where
  getCurrent :: F p -> Maybe' a
getCurrent (Now p
x) = p -> Maybe' a
forall p a. Producer p a => p -> Maybe' a
getCurrent p
x
  getCurrent (Wait O (F p)
_) = Maybe' a
forall a. Maybe' a
Nothing'
  
  getNext :: forall b. F p -> (forall q. Producer q a => O q -> b) -> b
getNext (Now p
x) forall q. Producer q a => O q -> b
cb = p -> (forall q. Producer q a => O q -> b) -> b
forall b. p -> (forall q. Producer q a => O q -> b) -> b
forall p a b.
Producer p a =>
p -> (forall q. Producer q a => O q -> b) -> b
getNext p
x O q -> b
forall q. Producer q a => O q -> b
cb
  getNext (Wait O (F p)
x) forall q. Producer q a => O q -> b
cb = O (F p) -> b
forall q. Producer q a => O q -> b
cb O (F p)
x

instance Producer (SigF a) a where
  getCurrent :: SigF a -> Maybe' a
getCurrent (a
x :>: O (F (SigF a))
_) = a -> Maybe' a
forall a. a -> Maybe' a
Just' a
x
  getNext :: forall b. SigF a -> (forall q. Producer q a => O q -> b) -> b
getNext (a
_ :>: O (F (SigF a))
xs) forall q. Producer q a => O q -> b
cb = O (F (SigF a)) -> b
forall q. Producer q a => O q -> b
cb O (F (SigF a))
xs



-- | @F a@ will produces a value of type @a@ after zero or more ticks
-- of some clocks
data F a = Now !a | Wait !(O (F a))



bindF :: F a -> Box (a -> F b) -> F b
bindF :: forall a b. F a -> Box (a -> F b) -> F b
bindF (Now a
x) Box (a -> F b)
f = Box (a -> F b) -> a -> F b
forall a. Box a -> a
unbox Box (a -> F b)
f a
x
bindF (Wait O (F a)
x) Box (a -> F b)
f = O (F b) -> F b
forall a. O (F a) -> F a
Wait (F b -> O (F b)
forall a. a -> O a
delay (F a -> Box (a -> F b) -> F b
forall a b. F a -> Box (a -> F b) -> F b
bindF (O (F a) -> F a
forall a. O a -> a
adv O (F a)
x) Box (a -> F b)
f))

mapF :: Box (a -> b) -> F a -> F b
mapF :: forall a b. Box (a -> b) -> F a -> F b
mapF Box (a -> b)
f F a
d = F a
d F a -> Box (a -> F b) -> F b
forall a b. F a -> Box (a -> F b) -> F b
`bindF` ((a -> F b) -> Box (a -> F b)
forall a. a -> Box a
box (\ a
x -> b -> F b
forall a. a -> F a
Now (Box (a -> b) -> a -> b
forall a. Box a -> a
unbox Box (a -> b)
f a
x)))


sync :: O (F a) -> O (F b) -> O (F a :* F b)
sync :: forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F a)
x O (F b)
y = (F a :* F b) -> O (F a :* F b)
forall a. a -> O a
delay (case O (F a) -> O (F b) -> Select (F a) (F b)
forall a b. O a -> O b -> Select a b
select O (F a)
x O (F b)
y of
                     Fst F a
x' O (F b)
y' -> (F a
x' F a -> F b -> F a :* F b
forall a b. a -> b -> a :* b
:* O (F b) -> F b
forall a. O (F a) -> F a
Wait O (F b)
y')
                     Snd O (F a)
x' F b
y' -> (O (F a) -> F a
forall a. O (F a) -> F a
Wait O (F a)
x' F a -> F b -> F a :* F b
forall a b. a -> b -> a :* b
:* F b
y')
                     Both F a
x' F b
y' -> (F a
x' F a -> F b -> F a :* F b
forall a b. a -> b -> a :* b
:* F b
y'))

syncF :: (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF :: forall a b. (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF (Now a
x) (Now b
y) = (a :* b) -> F (a :* b)
forall a. a -> F a
Now (a
x a -> b -> a :* b
forall a b. a -> b -> a :* b
:* b
y)
syncF (Wait O (F a)
x) (Now b
y) = O (F (a :* b)) -> F (a :* b)
forall a. O (F a) -> F a
Wait (F (a :* b) -> O (F (a :* b))
forall a. a -> O a
delay (F a -> b -> F (a :* b)
forall b a. Stable b => F a -> b -> F (a :* b)
syncA (O (F a) -> F a
forall a. O a -> a
adv O (F a)
x) b
y))
syncF (Now a
x) (Wait O (F b)
y) = O (F (a :* b)) -> F (a :* b)
forall a. O (F a) -> F a
Wait (F (a :* b) -> O (F (a :* b))
forall a. a -> O a
delay (a -> F b -> F (a :* b)
forall a b. Stable a => a -> F b -> F (a :* b)
syncB a
x (O (F b) -> F b
forall a. O a -> a
adv O (F b)
y)))
syncF (Wait O (F a)
x) (Wait O (F b)
y) = O (F (a :* b)) -> F (a :* b)
forall a. O (F a) -> F a
Wait (F (a :* b) -> O (F (a :* b))
forall a. a -> O a
delay (case O (F a) -> O (F b) -> Select (F a) (F b)
forall a b. O a -> O b -> Select a b
select O (F a)
x O (F b)
y of
                                         Fst F a
x' O (F b)
y' -> F a -> F b -> F (a :* b)
forall a b. (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF F a
x' (O (F b) -> F b
forall a. O (F a) -> F a
Wait O (F b)
y')
                                         Snd O (F a)
x' F b
y' -> F a -> F b -> F (a :* b)
forall a b. (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF (O (F a) -> F a
forall a. O (F a) -> F a
Wait O (F a)
x') F b
y'
                                         Both F a
x' F b
y' -> F a -> F b -> F (a :* b)
forall a b. (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF F a
x' F b
y'
                                      )) 

syncA :: (Stable b) => F a -> b -> F (a :* b)
syncA :: forall b a. Stable b => F a -> b -> F (a :* b)
syncA (Now a
x) b
y = (a :* b) -> F (a :* b)
forall a. a -> F a
Now (a
x a -> b -> a :* b
forall a b. a -> b -> a :* b
:* b
y)
syncA (Wait O (F a)
x) b
y = O (F (a :* b)) -> F (a :* b)
forall a. O (F a) -> F a
Wait (F (a :* b) -> O (F (a :* b))
forall a. a -> O a
delay (F a -> b -> F (a :* b)
forall b a. Stable b => F a -> b -> F (a :* b)
syncA (O (F a) -> F a
forall a. O a -> a
adv O (F a)
x) b
y))


syncB :: (Stable a) => a -> F b -> F (a :* b)
syncB :: forall a b. Stable a => a -> F b -> F (a :* b)
syncB a
x (Now b
y) = (a :* b) -> F (a :* b)
forall a. a -> F a
Now (a
x a -> b -> a :* b
forall a b. a -> b -> a :* b
:* b
y)
syncB a
x (Wait O (F b)
y) = O (F (a :* b)) -> F (a :* b)
forall a. O (F a) -> F a
Wait (F (a :* b) -> O (F (a :* b))
forall a. a -> O a
delay (a -> F b -> F (a :* b)
forall a b. Stable a => a -> F b -> F (a :* b)
syncB a
x (O (F b) -> F b
forall a. O a -> a
adv O (F b)
y)))


-- | @SigF a@ is a signal of values of type @a@. In contrast to 'Sig',
-- 'SigF' supports the 'filter' and 'filterMap' functions.
data SigF a = !a :>: !(O (F (SigF a)))


-- | Get the current value of a signal.
current :: SigF a -> a
current :: forall a. SigF a -> a
current (a
x :>: O (F (SigF a))
_) = a
x


-- | Get the future the signal.
future :: SigF a -> O (F (SigF a))
future :: forall a. SigF a -> O (F (SigF a))
future (a
_ :>: O (F (SigF a))
xs) = O (F (SigF a))
xs


mkSigF :: Box (O a) -> F (SigF a)
mkSigF :: forall a. Box (O a) -> F (SigF a)
mkSigF Box (O a)
b = O (F (SigF a)) -> F (SigF a)
forall a. O (F a) -> F a
Wait (Box (O a) -> O (F (SigF a))
forall a. Box (O a) -> O (F (SigF a))
mkSigF' Box (O a)
b) where

mkSigF' :: Box (O a) -> O (F (SigF a))
mkSigF' :: forall a. Box (O a) -> O (F (SigF a))
mkSigF' Box (O a)
b = F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay (SigF a -> F (SigF a)
forall a. a -> F a
Now (O a -> a
forall a. O a -> a
adv (Box (O a) -> O a
forall a. Box a -> a
unbox Box (O a)
b) a -> O (F (SigF a)) -> SigF a
forall a. a -> O (F (SigF a)) -> SigF a
:>: Box (O a) -> O (F (SigF a))
forall a. Box (O a) -> O (F (SigF a))
mkSigF' Box (O a)
b))


fromSig :: Sig a -> SigF a
fromSig :: forall a. Sig a -> SigF a
fromSig (a
x ::: O (Sig a)
xs) = a
x a -> O (F (SigF a)) -> SigF a
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay (SigF a -> F (SigF a)
forall a. a -> F a
Now (Sig a -> SigF a
forall a. Sig a -> SigF a
fromSig (O (Sig a) -> Sig a
forall a. O a -> a
adv O (Sig a)
xs)))

  
switchAwait :: F (SigF a) -> F (SigF a) -> F(SigF a)
switchAwait :: forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait F (SigF a)
_ (Now SigF a
ys) = SigF a -> F (SigF a)
forall a. a -> F a
Now SigF a
ys
switchAwait (Now (a
x :>: O (F (SigF a))
xs)) (Wait O (F (SigF a))
ys) = SigF a -> F (SigF a)
forall a. a -> F a
Now (a
x a -> O (F (SigF a)) -> SigF a
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF a) -> F (SigF a))
-> (F (SigF a) :* F (SigF a)) -> F (SigF a)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' F (SigF a) -> F (SigF a) -> F (SigF a)
forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait (O (F (SigF a) :* F (SigF a)) -> F (SigF a) :* F (SigF a)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF a)) -> O (F (SigF a) :* F (SigF a))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
xs O (F (SigF a))
ys)) ))
switchAwait (Wait O (F (SigF a))
xs) (Wait O (F (SigF a))
ys) = O (F (SigF a)) -> F (SigF a)
forall a. O (F a) -> F a
Wait (F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF a) -> F (SigF a))
-> (F (SigF a) :* F (SigF a)) -> F (SigF a)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' F (SigF a) -> F (SigF a) -> F (SigF a)
forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait (O (F (SigF a) :* F (SigF a)) -> F (SigF a) :* F (SigF a)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF a)) -> O (F (SigF a) :* F (SigF a))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
xs O (F (SigF a))
ys)) ))

switch :: SigF a -> F (SigF a) -> SigF a
switch :: forall a. SigF a -> F (SigF a) -> SigF a
switch SigF a
_ (Now SigF a
ys) = SigF a
ys
switch (a
x :>: O (F (SigF a))
xs) (Wait O (F (SigF a))
ys) = a
x a -> O (F (SigF a)) -> SigF a
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF a) -> F (SigF a))
-> (F (SigF a) :* F (SigF a)) -> F (SigF a)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' F (SigF a) -> F (SigF a) -> F (SigF a)
forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait (O (F (SigF a) :* F (SigF a)) -> F (SigF a) :* F (SigF a)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF a)) -> O (F (SigF a) :* F (SigF a))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
xs O (F (SigF a))
ys)))

switchS :: Stable a => SigF a -> F (a -> SigF a) -> SigF a
switchS :: forall a. Stable a => SigF a -> F (a -> SigF a) -> SigF a
switchS (a
x :>: O (F (SigF a))
_) (Now a -> SigF a
f) = a -> SigF a
f a
x
switchS (a
x :>: O (F (SigF a))
xs) (Wait O (F (a -> SigF a))
ys) = a
x a -> O (F (SigF a)) -> SigF a
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay ((F (SigF a) -> F (a -> SigF a) -> F (SigF a))
-> (F (SigF a) :* F (a -> SigF a)) -> F (SigF a)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
x) (O (F (SigF a) :* F (a -> SigF a)) -> F (SigF a) :* F (a -> SigF a)
forall a. O a -> a
adv (O (F (SigF a))
-> O (F (a -> SigF a)) -> O (F (SigF a) :* F (a -> SigF a))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
xs O (F (a -> SigF a))
ys)))

switchAwaitS :: Stable a => a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS :: forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
_ (Now (a
x :>: O (F (SigF a))
_)) (Now a -> SigF a
f) = SigF a -> F (SigF a)
forall a. a -> F a
Now (a -> SigF a
f a
x)
switchAwaitS a
_ (Now (a
x :>: O (F (SigF a))
xs)) (Wait O (F (a -> SigF a))
ys) =
  SigF a -> F (SigF a)
forall a. a -> F a
Now (a
x a -> O (F (SigF a)) -> SigF a
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay ((F (SigF a) -> F (a -> SigF a) -> F (SigF a))
-> (F (SigF a) :* F (a -> SigF a)) -> F (SigF a)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
x) (O (F (SigF a) :* F (a -> SigF a)) -> F (SigF a) :* F (a -> SigF a)
forall a. O a -> a
adv (O (F (SigF a))
-> O (F (a -> SigF a)) -> O (F (SigF a) :* F (a -> SigF a))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
xs O (F (a -> SigF a))
ys))))
switchAwaitS a
x (Wait O (F (SigF a))
_) (Now a -> SigF a
f) = SigF a -> F (SigF a)
forall a. a -> F a
Now (a -> SigF a
f a
x)
switchAwaitS a
x (Wait O (F (SigF a))
xs) (Wait O (F (a -> SigF a))
ys) = O (F (SigF a)) -> F (SigF a)
forall a. O (F a) -> F a
Wait (F (SigF a) -> O (F (SigF a))
forall a. a -> O a
delay ((F (SigF a) -> F (a -> SigF a) -> F (SigF a))
-> (F (SigF a) :* F (a -> SigF a)) -> F (SigF a)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
x) (O (F (SigF a) :* F (a -> SigF a)) -> F (SigF a) :* F (a -> SigF a)
forall a. O a -> a
adv (O (F (SigF a))
-> O (F (a -> SigF a)) -> O (F (SigF a) :* F (a -> SigF a))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
xs O (F (a -> SigF a))
ys))))



filterMapAwait :: Box (a -> Maybe' b) -> F(SigF a) -> F (SigF b)
filterMapAwait :: forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (Wait O (F (SigF a))
xs) = O (F (SigF b)) -> F (SigF b)
forall a. O (F a) -> F a
Wait (F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
xs)))
filterMapAwait Box (a -> Maybe' b)
f (Now (a
x :>: O (F (SigF a))
xs)) = case Box (a -> Maybe' b) -> a -> Maybe' b
forall a. Box a -> a
unbox Box (a -> Maybe' b)
f a
x of
                                     Just' b
y  -> SigF b -> F (SigF b)
forall a. a -> F a
Now (b
y b -> O (F (SigF b)) -> SigF b
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
xs)))
                                     Maybe' b
Nothing' -> O (F (SigF b)) -> F (SigF b)
forall a. O (F a) -> F a
Wait (F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
xs)))

filterMap :: Box (a -> Maybe' b) -> SigF a -> F (SigF b)
filterMap :: forall a b. Box (a -> Maybe' b) -> SigF a -> F (SigF b)
filterMap Box (a -> Maybe' b)
f SigF a
xs = Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (SigF a -> F (SigF a)
forall a. a -> F a
Now SigF a
xs)


filterAwait :: Box (a -> Bool) -> F( SigF a) -> F (SigF a)
filterAwait :: forall a. Box (a -> Bool) -> F (SigF a) -> F (SigF a)
filterAwait Box (a -> Bool)
p = Box (a -> Maybe' a) -> F (SigF a) -> F (SigF a)
forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait ((a -> Maybe' a) -> Box (a -> Maybe' a)
forall a. a -> Box a
box (\ a
x -> if Box (a -> Bool) -> a -> Bool
forall a. Box a -> a
unbox Box (a -> Bool)
p a
x then a -> Maybe' a
forall a. a -> Maybe' a
Just' a
x else Maybe' a
forall a. Maybe' a
Nothing'))

filter :: Box (a -> Bool) -> SigF a -> F (SigF a)
filter :: forall a. Box (a -> Bool) -> SigF a -> F (SigF a)
filter Box (a -> Bool)
p = Box (a -> Maybe' a) -> SigF a -> F (SigF a)
forall a b. Box (a -> Maybe' b) -> SigF a -> F (SigF b)
filterMap ((a -> Maybe' a) -> Box (a -> Maybe' a)
forall a. a -> Box a
box (\ a
x -> if Box (a -> Bool) -> a -> Bool
forall a. Box a -> a
unbox Box (a -> Bool)
p a
x then a -> Maybe' a
forall a. a -> Maybe' a
Just' a
x else Maybe' a
forall a. Maybe' a
Nothing'))

trigger :: Stable b => Box (a -> b -> c) -> SigF a -> SigF b -> SigF c
trigger :: forall b a c.
Stable b =>
Box (a -> b -> c) -> SigF a -> SigF b -> SigF c
trigger Box (a -> b -> c)
f (a
a :>: O (F (SigF a))
as) (b
b :>: O (F (SigF b))
bs) =
  Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>:
  F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs)))

triggerAwait :: Stable b => Box (a -> b -> c) -> F (SigF a) -> SigF b -> F (SigF c)
triggerAwait :: forall b a c.
Stable b =>
Box (a -> b -> c) -> F (SigF a) -> SigF b -> F (SigF c)
triggerAwait Box (a -> b -> c)
f (Now (a
a :>: O (F (SigF a))
as)) (b
b :>: O (F (SigF b))
bs)
  = SigF c -> F (SigF c)
forall a. a -> F a
Now (Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
triggerAwait Box (a -> b -> c)
f (Wait O (F (SigF a))
as) (b
b :>: O (F (SigF b))
bs)
  = O (F (SigF c)) -> F (SigF c)
forall a. O (F a) -> F a
Wait (F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))

trigger' :: Stable b => b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' :: forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f (Now (a
a :>: O (F (SigF a))
as)) (Wait O (F (SigF b))
bs) =
  SigF c -> F (SigF c)
forall a. a -> F a
Now (Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
trigger' b
_ Box (a -> b -> c)
f (Now (a
a :>: O (F (SigF a))
as)) (Now (b
b :>: O (F (SigF b))
bs)) =
  SigF c -> F (SigF c)
forall a. a -> F a
Now (Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
trigger' b
b Box (a -> b -> c)
f (Wait O (F (SigF a))
as) (Wait O (F (SigF b))
bs) =
  O (F (SigF c)) -> F (SigF c)
forall a. O (F a) -> F a
Wait (F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
trigger' b
_ Box (a -> b -> c)
f (Wait O (F (SigF a))
as) (Now (b
b :>: O (F (SigF b))
bs)) =
  O (F (SigF c)) -> F (SigF c)
forall a. O (F a) -> F a
Wait (F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall b a c.
Stable b =>
b -> Box (a -> b -> c) -> F (SigF a) -> F (SigF b) -> F (SigF c)
trigger' b
b Box (a -> b -> c)
f) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))


mapAwait :: Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait :: forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (Now (a
x :>: O (F (SigF a))
xs)) = SigF b -> F (SigF b)
forall a. a -> F a
Now (Box (a -> b) -> a -> b
forall a. Box a -> a
unbox Box (a -> b)
f a
x b -> O (F (SigF b)) -> SigF b
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (a -> b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
xs)))
mapAwait Box (a -> b)
f (Wait O (F (SigF a))
xs) = O (F (SigF b)) -> F (SigF b)
forall a. O (F a) -> F a
Wait (F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (a -> b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
xs)))

map :: Box (a -> b) -> SigF a -> SigF b
map :: forall a b. Box (a -> b) -> SigF a -> SigF b
map Box (a -> b)
f (a
x :>: O (F (SigF a))
xs) = Box (a -> b) -> a -> b
forall a. Box a -> a
unbox Box (a -> b)
f a
x b -> O (F (SigF b)) -> SigF b
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (a -> b) -> F (SigF a) -> F (SigF b)
forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
xs))



zipWith :: (Stable a, Stable b) => Box(a -> b -> c) -> SigF a -> SigF b -> SigF c
zipWith :: forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c) -> SigF a -> SigF b -> SigF c
zipWith Box (a -> b -> c)
f (a
a :>: O (F (SigF a))
as) (b
b :>: O (F (SigF b))
bs) = Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait Box (a -> b -> c)
f a
a b
b) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs)))

zipWithAwait :: (Stable a, Stable b) => Box(a -> b -> c) -> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait :: forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait Box (a -> b -> c)
f a
_ b
_ (Now (a
a :>: O (F (SigF a))
as)) (Now (b
b :>: O (F (SigF b))
bs)) = SigF c -> F (SigF c)
forall a. a -> F a
Now (Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait Box (a -> b -> c)
f a
a b
b) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
zipWithAwait Box (a -> b -> c)
f a
_ b
b (Now (a
a :>: O (F (SigF a))
as)) (Wait O (F (SigF b))
bs) = SigF c -> F (SigF c)
forall a. a -> F a
Now (Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait Box (a -> b -> c)
f a
a b
b) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
zipWithAwait Box (a -> b -> c)
f a
a b
_ (Wait O (F (SigF a))
as) (Now (b
b :>: O (F (SigF b))
bs)) = SigF c -> F (SigF c)
forall a. a -> F a
Now (Box (a -> b -> c) -> a -> b -> c
forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b c -> O (F (SigF c)) -> SigF c
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait Box (a -> b -> c)
f a
a b
b) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))
zipWithAwait Box (a -> b -> c)
f a
a b
b (Wait O (F (SigF a))
as) (Wait O (F (SigF b))
bs) = O (F (SigF c)) -> F (SigF c)
forall a. O (F a) -> F a
Wait (F (SigF c) -> O (F (SigF c))
forall a. a -> O a
delay ((F (SigF a) -> F (SigF b) -> F (SigF c))
-> (F (SigF a) :* F (SigF b)) -> F (SigF c)
forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
forall a b c.
(Stable a, Stable b) =>
Box (a -> b -> c)
-> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)
zipWithAwait Box (a -> b -> c)
f a
a b
b) (O (F (SigF a) :* F (SigF b)) -> F (SigF a) :* F (SigF b)
forall a. O a -> a
adv (O (F (SigF a)) -> O (F (SigF b)) -> O (F (SigF a) :* F (SigF b))
forall a b. O (F a) -> O (F b) -> O (F a :* F b)
sync O (F (SigF a))
as O (F (SigF b))
bs))))

scan :: (Stable b) => Box(b -> a -> b) -> b -> SigF a -> SigF b
scan :: forall b a. Stable b => Box (b -> a -> b) -> b -> SigF a -> SigF b
scan Box (b -> a -> b)
f b
acc (a
a :>: O (F (SigF a))
as) = b
acc' b -> O (F (SigF b)) -> SigF b
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc' (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
as))
  where acc' :: b
acc' = Box (b -> a -> b) -> b -> a -> b
forall a. Box a -> a
unbox Box (b -> a -> b)
f b
acc a
a

scanAwait :: (Stable b) => Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait :: forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc (Now (a
a :>: O (F (SigF a))
as)) = SigF b -> F (SigF b)
forall a. a -> F a
Now (b
acc' b -> O (F (SigF b)) -> SigF b
forall a. a -> O (F (SigF a)) -> SigF a
:>: F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc' (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
as)))
  where acc' :: b
acc' = Box (b -> a -> b) -> b -> a -> b
forall a. Box a -> a
unbox Box (b -> a -> b)
f b
acc a
a
scanAwait Box (b -> a -> b)
f b
acc (Wait O (F (SigF a))
as) = O (F (SigF b)) -> F (SigF b)
forall a. O (F a) -> F a
Wait (F (SigF b) -> O (F (SigF b))
forall a. a -> O a
delay (Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc (O (F (SigF a)) -> F (SigF a)
forall a. O a -> a
adv O (F (SigF a))
as)))