{-# 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

{-# ANN module AsyncRattus #-}

newtype OneShot a = OneShot (F a)

instance Producer (OneShot a) a where
  getCurrent :: OneShot a -> Maybe' a
getCurrent (OneShot (Now a
x)) = forall a. a -> Maybe' a
Just' a
x
  getCurrent (OneShot (Wait O (F 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 = forall q. Producer q a => O q -> b
cb (forall a. O a
never :: O (OneShot a))
  getNext (OneShot (Wait O (F a)
x)) forall q. Producer q a => O q -> b
cb = forall q. Producer q a => O q -> b
cb (forall a. a -> O a
delay (forall a. F a -> OneShot a
OneShot (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) = forall p a. Producer p a => p -> Maybe' a
getCurrent p
x
  getCurrent (Wait O (F p)
_) = 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 = forall p a b.
Producer p a =>
p -> (forall q. Producer q a => O q -> b) -> b
getNext p
x forall q. Producer q a => O q -> b
cb
  getNext (Wait O (F p)
x) forall q. Producer q a => O q -> b
cb = 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))
_) = 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 = 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 = forall a. Box a -> a
unbox Box (a -> F b)
f a
x
bindF (Wait O (F a)
x) Box (a -> F b)
f = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b. F a -> Box (a -> F b) -> F b
bindF (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 forall a b. F a -> Box (a -> F b) -> F b
`bindF` (forall a. a -> Box a
box (\ a
x -> forall a. a -> F a
Now (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 = forall a. a -> O a
delay (case 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' forall a b. a -> b -> a :* b
:* forall a. O (F a) -> F a
Wait O (F b)
y')
                     Snd O (F a)
x' F b
y' -> (forall a. O (F a) -> F a
Wait O (F a)
x' forall a b. a -> b -> a :* b
:* F b
y')
                     Both F a
x' F b
y' -> (F a
x' 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) = forall a. a -> F a
Now (a
x forall a b. a -> b -> a :* b
:* b
y)
syncF (Wait O (F a)
x) (Now b
y) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall b a. Stable b => F a -> b -> F (a :* b)
syncA (forall a. O a -> a
adv O (F a)
x) b
y))
syncF (Now a
x) (Wait O (F b)
y) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b. Stable a => a -> F b -> F (a :* b)
syncB a
x (forall a. O a -> a
adv O (F b)
y)))
syncF (Wait O (F a)
x) (Wait O (F b)
y) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (case 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' -> forall a b. (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF F a
x' (forall a. O (F a) -> F a
Wait O (F b)
y')
                                         Snd O (F a)
x' F b
y' -> forall a b. (Stable a, Stable b) => F a -> F b -> F (a :* b)
syncF (forall a. O (F a) -> F a
Wait O (F a)
x') F b
y'
                                         Both F a
x' F b
y' -> 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 = forall a. a -> F a
Now (a
x forall a b. a -> b -> a :* b
:* b
y)
syncA (Wait O (F a)
x) b
y = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall b a. Stable b => F a -> b -> F (a :* b)
syncA (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) = forall a. a -> F a
Now (a
x forall a b. a -> b -> a :* b
:* b
y)
syncB a
x (Wait O (F b)
y) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b. Stable a => a -> F b -> F (a :* b)
syncB a
x (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 = forall a. O (F a) -> F a
Wait (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 = forall a. a -> O a
delay (forall a. a -> F a
Now (forall a. O a -> a
adv (forall a. Box a -> a
unbox Box (O a)
b) forall a. a -> O (F (SigF a)) -> 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 forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a. a -> F a
Now (forall a. Sig a -> SigF a
fromSig (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) = forall a. a -> F a
Now SigF a
ys
switchAwait (Now (a
x :>: O (F (SigF a))
xs)) (Wait O (F (SigF a))
ys) = forall a. a -> F a
Now (a
x forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait (forall a. O a -> a
adv (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) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait (forall a. O a -> a
adv (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 forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' forall a. F (SigF a) -> F (SigF a) -> F (SigF a)
switchAwait (forall a. O a -> a
adv (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 forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
x) (forall a. O a -> a
adv (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) = 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) =
  forall a. a -> F a
Now (a
x forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
x) (forall a. O a -> a
adv (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) = 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) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (forall a.
Stable a =>
a -> F (SigF a) -> F (a -> SigF a) -> F (SigF a)
switchAwaitS a
x) (forall a. O a -> a
adv (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) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (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 forall a. Box a -> a
unbox Box (a -> Maybe' b)
f a
x of
                                     Just' b
y  -> forall a. a -> F a
Now (b
y forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (forall a. O a -> a
adv O (F (SigF a))
xs)))
                                     Maybe' b
Nothing' -> forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (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 = forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait Box (a -> Maybe' b)
f (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 = forall a b. Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)
filterMapAwait (forall a. a -> Box a
box (\ a
x -> if forall a. Box a -> a
unbox Box (a -> Bool)
p a
x then forall a. a -> Maybe' a
Just' a
x else 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 = forall a b. Box (a -> Maybe' b) -> SigF a -> F (SigF b)
filterMap (forall a. a -> Box a
box (\ a
x -> if forall a. Box a -> a
unbox Box (a -> Bool)
p a
x then forall a. a -> Maybe' a
Just' a
x else 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) =
  forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>:
  forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)
  = forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)
  = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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) =
  forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)) =
  forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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) =
  forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)) =
  forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)) = forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b)
f a
x forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (forall a. O a -> a
adv O (F (SigF a))
xs)))
mapAwait Box (a -> b)
f (Wait O (F (SigF a))
xs) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (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) = forall a. Box a -> a
unbox Box (a -> b)
f a
x forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b. Box (a -> b) -> F (SigF a) -> F (SigF b)
mapAwait Box (a -> b)
f (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) = forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)) = forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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) = forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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)) = forall a. a -> F a
Now (forall a. Box a -> a
unbox Box (a -> b -> c)
f a
a b
b forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall a b c. (a -> b -> c) -> (a :* b) -> c
uncurry' (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) (forall a. O a -> a
adv (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' forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc' (forall a. O a -> a
adv O (F (SigF a))
as))
  where acc' :: b
acc' = 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)) = forall a. a -> F a
Now (b
acc' forall a. a -> O (F (SigF a)) -> SigF a
:>: forall a. a -> O a
delay (forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc' (forall a. O a -> a
adv O (F (SigF a))
as)))
  where acc' :: b
acc' = 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) = forall a. O (F a) -> F a
Wait (forall a. a -> O a
delay (forall b a.
Stable b =>
Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)
scanAwait Box (b -> a -> b)
f b
acc (forall a. O a -> a
adv O (F (SigF a))
as)))