AsyncRattus.Future

Programming with futures.

Documentation

data F a

F a will produces a value of type a after zero or more ticks of some clocks

Constructors

Now !a

Wait !(O (F a))

Instances

Producer p a => Producer (F p) a

Defined in AsyncRattus.Future

Methods

getCurrent :: F p -> Maybe' a

getNext :: F p -> (forall q. Producer q a => O q -> b) -> b

data SigF a

SigF a is a signal of values of type a. In contrast to Sig, SigF supports the filter and filterMap functions.

Constructors

!a :>: !(O (F (SigF a)))

Instances

Producer (SigF a) a

Defined in AsyncRattus.Future

Methods

getCurrent :: SigF a -> Maybe' a

getNext :: SigF a -> (forall q. Producer q a => O q -> b) -> b

mkSigF :: Box (O a) -> F (SigF a)

mkSigF' :: Box (O a) -> O (F (SigF a))

current :: SigF a -> a

Get the current value of a signal.

future :: SigF a -> O (F (SigF a))

Get the future the signal.

bindF :: F a -> Box (a -> F b) -> F b

mapF :: Box (a -> b) -> F a -> F b

sync :: O (F a) -> O (F b) -> O (F a :* F b)

syncF :: (Stable a, Stable b) => F a -> F b -> F (a :* b)

switchAwait :: F (SigF a) -> F (SigF a) -> F (SigF a)

switch :: SigF a -> F (SigF a) -> SigF a

switchS :: Stable a => SigF a -> F (a -> SigF a) -> SigF a

filterMap :: Box (a -> Maybe' b) -> SigF a -> F (SigF b)

filterMapAwait :: Box (a -> Maybe' b) -> F (SigF a) -> F (SigF b)

filterAwait :: Box (a -> Bool) -> F (SigF a) -> F (SigF a)

filter :: Box (a -> Bool) -> SigF a -> F (SigF a)

trigger :: Stable b => Box (a -> b -> c) -> SigF a -> SigF b -> SigF c

triggerAwait :: Stable b => Box (a -> b -> c) -> F (SigF a) -> SigF b -> F (SigF c)

map :: Box (a -> b) -> SigF a -> SigF b

mapAwait :: Box (a -> b) -> F (SigF a) -> F (SigF b)

zipWith :: (Stable a, Stable b) => Box (a -> b -> c) -> SigF a -> SigF b -> SigF c

zipWithAwait :: (Stable a, Stable b) => Box (a -> b -> c) -> a -> b -> F (SigF a) -> F (SigF b) -> F (SigF c)

fromSig :: Sig a -> SigF a

scan :: Stable b => Box (b -> a -> b) -> b -> SigF a -> SigF b

scanAwait :: Stable b => Box (b -> a -> b) -> b -> F (SigF a) -> F (SigF b)