Rattus.Yampa

A simply Yampa-like library for signal functions.

Documentation

data SF a b

Signal functions from inputs of type a to outputs of type b.

Instances

Arrow SF

Defined in Rattus.Yampa

Methods

arrBox :: Box (b -> c) -> SF b c

first :: SF b c -> SF (b, d) (c, d)

second :: SF b c -> SF (d, b) (d, c)

(***) :: SF b c -> SF b' c' -> SF (b, b') (c, c')

(&&&) :: SF b c -> SF b c' -> SF b (c, c')

Category SF

Defined in Rattus.Yampa

Methods

id :: forall (a :: k). SF a a

(.) :: forall (b :: k) (c :: k) (a :: k). SF b c -> SF a b -> SF a c

identity :: SF a a

The identity signal function that does nothing.

compose :: SF b c -> SF a b -> SF a c

Compose two signal functions.

switch :: SF a (b :* Maybe' c) -> Box (c -> SF a b) -> SF a b

switch s f behaves like s composed with arr fst until s produces a value of the form Just' c in the second component. From then on it behaves like $f c@.

rSwitch :: SF a b -> SF (a :* Maybe' (SF a b)) b

rSwitch s behaves like s, but every time the second input is of the form Just' s' it will change behaviour to s'.

constant :: Stable b => b -> SF a b

Constant signal function.

loopPre :: c -> SF (a :* c) (b :* O c) -> SF a b

Loop with an initial value for the signal being fed back.

Note: The type of loopPre is different from Yampa's as we need the O type here.

stepSF :: SF a b -> DTime -> a -> O (SF a b) :* b

Run a signal function for one step.

initially :: a -> SF a a

Override initial value of input signal.

integral :: (Stable a, VectorSpace a s) => a -> SF a a

Compute the integral of a signal. The first argument is the offset.

(-->) :: b -> SF a b -> SF a b

The output at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.

(-:>) :: b -> O (SF a b) -> SF a b

Insert a sample in the output, and from that point on, behave like the given signal function.

Note: The type of -:> is different from Yampa's: The second argument must be delayed (or boxed).

(>--) :: a -> SF a b -> SF a b

The input at time zero is the first argument, and from that point on it behaves like the signal function passed as second argument.

(-=>) :: (b -> b) -> SF a b -> SF a b

Apply a function to the first output value at time zero.

(>=-) :: (a -> a) -> SF a b -> SF a b

Apply a function to the first input value at time zero.

(^>>) :: Arrow a => Box (b -> c) -> a c d -> a b d

Precomposition with a pure function.

(>>^) :: Arrow a => a b c -> Box (c -> d) -> a b d

Postcomposition with a pure function.

(<<^) :: Arrow a => a c d -> Box (b -> c) -> a b d

Precomposition with a pure function (right-to-left variant).

(^<<) :: Arrow a => Box (c -> d) -> a b c -> a b d

Postcomposition with a pure function (right-to-left variant).

module Rattus.Arrow

(>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1

Left-to-right composition