rhine-0.1.0.0: Functional Reactive Programming with type-level clocks

Safe HaskellNone
LanguageHaskell2010

FRP.Rhine.SF.Combinators

Contents

Description

General mnemonic for combinators:

  • @ annotates a data processing unit such as a signal function or a 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 functions.

(@@) :: (cl ~ Leftmost cl, cl ~ Rightmost cl) => SyncSF m cl a b -> cl -> Rhine m cl a b infix 5 Source #

Create a synchronous Rhine by combining a synchronous SF with a matching clock. Synchronicity is ensured by requiring that data enters (Leftmost cl) and leaves (Rightmost cl) the system at the same as it is processed (cl).

data ResamplingPoint m cla clb a b Source #

A point at which sequential asynchronous composition ("resampling") of signal functions can happen.

Constructors

ResamplingPoint (ResamplingBuffer m (Rightmost cla) (Leftmost clb) a b) (Schedule m cla clb) 

(-@-) :: ResamplingBuffer m (Rightmost cl1) (Leftmost cl2) a b -> Schedule m cl1 cl2 -> ResamplingPoint m cl1 cl2 a b infix 8 Source #

Syntactic sugar for ResamplingPoint.

data RhineAndResamplingPoint m cl1 cl2 a c Source #

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

Constructors

RhineAndResamplingPoint (Rhine m cl1 a b) (ResamplingPoint m cl1 cl2 b c) 

(>--) :: Rhine m cl1 a b -> ResamplingPoint m cl1 cl2 b c -> RhineAndResamplingPoint m cl1 cl2 a c infix 2 Source #

Syntactic sugar for RhineAndResamplingPoint.

(-->) :: (Clock m cl1, Clock m cl2, TimeDomainOf cl1 ~ TimeDomainOf cl2, TimeDomainOf (Rightmost cl1) ~ TimeDomainOf cl1, TimeDomainOf (Leftmost cl2) ~ TimeDomainOf cl2, Clock m (Rightmost cl1), Clock m (Leftmost cl2)) => RhineAndResamplingPoint m cl1 cl2 a b -> Rhine m cl2 b c -> Rhine m (SequentialClock m 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 (Rightmost cl1) (Leftmost cl2)   b c
rb    =  ...

sched :: Schedule         m            cl1            cl2
sched =  ...

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

data RhineParallelAndSchedule m cl1 cl2 a b Source #

A purely syntactical convenience construction allowing for ternary syntax for parallel composition, described below.

Constructors

RhineParallelAndSchedule (Rhine m cl1 a b) (Schedule m cl1 cl2) 

(**@) :: Rhine m cl1 a b -> Schedule m cl1 cl2 -> RhineParallelAndSchedule m cl1 cl2 a b infix 4 Source #

Syntactic sugar for RhineParallelAndSchedule.

(@**) :: (Clock m cl1, Clock m cl2, TimeDomainOf cl1 ~ TimeDomainOf (Rightmost cl1), TimeDomainOf cl2 ~ TimeDomainOf (Rightmost cl2), TimeDomainOf cl1 ~ TimeDomainOf (Leftmost cl1), TimeDomainOf cl2 ~ TimeDomainOf (Leftmost cl2), TimeDomainOf cl1 ~ TimeDomainOf cl2) => RhineParallelAndSchedule m cl1 cl2 a b -> Rhine m cl2 a b -> Rhine m (ParallelClock m cl1 cl2) a b infix 3 Source #

The combinators for parallel composition allow for the following syntax:

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

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

sched :: Schedule m                cl1 cl2
sched =  ...

rh    :: Rhine    m (ParallelClock cl1 cl2) a b
rh    =  rh1 **@ sched @** rh2