rhine-1.3: Functional Reactive Programming with type-level clocks
Safe HaskellSafe-Inferred
LanguageHaskell2010

FRP.Rhine.Reactimation.Combinators

Description

Combinators to create Rhines (main programs) from basic components such as ClSFs, clocks, ResamplingBuffers and Schedules.

The combinator names are often mixed of the symbols , * and >@, and several other symbols. The general mnemonic for combinator names is:

  • @ annotates a data processing unit such as a signal function, network or buffer with temporal information like a clock or a schedule.
  • * composes parallely.
  • > composes sequentially.
Synopsis

Combinators and syntactic sugar for high-level composition of signal networks.

(@@) :: (cl ~ In cl, cl ~ Out cl) => ClSF m cl a b -> cl -> Rhine m cl a b infix 5 Source #

Create a synchronous Rhine by combining a clocked signal function with a matching clock. Synchronicity is ensured by requiring that data enters (In cl) and leaves (Out cl) the system at the same as it is processed (cl).

data RhineAndResamplingBuffer m cl1 inCl2 a c Source #

A purely syntactical convenience construction enabling quadruple syntax for sequential composition, as described below.

Constructors

forall b. RhineAndResamplingBuffer (Rhine m cl1 a b) (ResamplingBuffer m (Out cl1) inCl2 b c) 

(>--) :: Rhine m cl1 a b -> ResamplingBuffer m (Out cl1) inCl2 b c -> RhineAndResamplingBuffer m cl1 inCl2 a c infix 2 Source #

Syntactic sugar for RhineAndResamplingBuffer.

(-->) :: (Clock m cl1, Clock m cl2, Time cl1 ~ Time cl2, Time (Out cl1) ~ Time cl1, Time (In cl2) ~ Time cl2, Clock m (Out cl1), Clock m (Out cl2), Clock m (In cl1), Clock m (In cl2), In cl2 ~ inCl2, GetClockProxy cl1, GetClockProxy cl2) => RhineAndResamplingBuffer m cl1 inCl2 a b -> Rhine m cl2 b c -> Rhine m (SequentialClock cl1 cl2) a c infixr 1 Source #

The combinators for sequential composition allow for the following syntax:

rh1   :: Rhine            m      cl1           a b
rh1   =  ...

rh2   :: Rhine            m               cl2      c d
rh2   =  ...

rb    :: ResamplingBuffer m (Out cl1) (In cl2)   b c
rb    =  ...

rh    :: Rhine m (SequentialClock cl1 cl2) a d
rh    =  rh1 >-- rb --> rh2

(+@+) :: (Monad m, Clock m clL, Clock m clR, Clock m (Out clL), Clock m (Out clR), GetClockProxy clL, GetClockProxy clR, Time clL ~ Time (Out clL), Time clR ~ Time (Out clR), Time clL ~ Time (In clL), Time clR ~ Time (In clR), Time clL ~ Time clR) => Rhine m clL a b -> Rhine m clR a c -> Rhine m (ParallelClock clL clR) a (Either b c) infix 3 Source #

The combinators for parallel composition allow for the following syntax:

rh1   :: Rhine m                clL      a         b
rh1   =  ...

rh2   :: Rhine m                    clR  a           c
rh2   =  ...

rh    :: Rhine m (ParallelClock clL clR) a (Either b c)
rh    =  rh1 +@+ rh2

(|@|) :: (Monad m, Clock m clL, Clock m clR, Clock m (Out clL), Clock m (Out clR), GetClockProxy clL, GetClockProxy clR, Time clL ~ Time (Out clL), Time clR ~ Time (Out clR), Time clL ~ Time (In clL), Time clR ~ Time (In clR), Time clL ~ Time clR) => Rhine m clL a b -> Rhine m clR a b -> Rhine m (ParallelClock clL clR) a b infix 3 Source #

The combinators for parallel composition allow for the following syntax:

rh1   :: Rhine m                clL      a b
rh1   =  ...

rh2   :: Rhine m                    clR  a b
rh2   =  ...

rh    :: Rhine m (ParallelClock clL clR) a b
rh    =  rh1 |@| rh2

(@>>^) :: Monad m => Rhine m cl a b -> (b -> c) -> Rhine m cl a c Source #

Postcompose a Rhine with a pure function.

(^>>@) :: Monad m => (a -> b) -> Rhine m cl b c -> Rhine m cl a c Source #

Precompose a Rhine with a pure function.

(@>-^) :: (Clock m (Out cl), Time cl ~ Time (Out cl)) => Rhine m cl a b -> ClSF m (Out cl) b c -> Rhine m cl a c Source #

Postcompose a Rhine with a ClSF.

(^->@) :: (Clock m (In cl), Time cl ~ Time (In cl)) => ClSF m (In cl) a b -> Rhine m cl b c -> Rhine m cl a c Source #

Precompose a Rhine with a ClSF.