machinecell-4.0.0: Arrow based stream transducers

Safe HaskellSafe
LanguageHaskell2010

Control.Arrow.Machine.Misc.Discrete

Contents

Synopsis

Discrete type

This module should be imported manually. Qualified import is recommended.

This module provides an abstraction that continuous values with finite number of changing points.

>>> import qualified Control.Arrow.Machine.Misc.Discrete as D
>>> P.run (D.hold "apple" >>> D.arr reverse >>> D.edge) ["orange", "grape"]
["elppa","egnaro","eparg"]

In above example, input data of "reverse" is continuous. But the "D.edge" transducer extracts changing points without calling string comparison.

This is possible because the intermediate type T has the information of changes together with the value information.

data T a Source #

The discrete signal type.

updates :: T a -> Event () Source #

value :: T a -> a Source #

arr :: Monad m => (b -> c) -> ProcessT m (T b) (T c) Source #

arr2 :: Monad m => (b1 -> b2 -> c) -> ProcessT m (T b1, T b2) (T c) Source #

arr3 :: Monad m => (b1 -> b2 -> b3 -> c) -> ProcessT m (T b1, T b2, T b3) (T c) Source #

arr4 :: Monad m => (b1 -> b2 -> b3 -> b4 -> c) -> ProcessT m (T b1, T b2, T b3, T b4) (T c) Source #

arr5 :: Monad m => (b1 -> b2 -> b3 -> b4 -> b5 -> c) -> ProcessT m (T b1, T b2, T b3, T b4, T b5) (T c) Source #

constant :: Monad m => c -> ProcessT m b (T c) Source #

unsafeConstant :: Monad m => c -> ProcessT m b (T c) Source #

Constant without initial notifications. Users must manage initialization manually.

hold :: Monad m => b -> ProcessT m (Event b) (T b) Source #

accum :: Monad m => b -> ProcessT m (Event (b -> b)) (T b) Source #

fromEq :: (Monad m, Eq b) => ProcessT m b (T b) Source #

edge :: Monad m => ProcessT m (T b) (Event b) Source #

asUpdater :: Monad m => (b -> m c) -> ProcessT m (T b) (Event c) Source #

kSwitch :: Monad m => ProcessT m b (T c) -> ProcessT m (b, T c) (Event t) -> (ProcessT m b (T c) -> t -> ProcessT m b (T c)) -> ProcessT m b (T c) Source #

dkSwitch :: Monad m => ProcessT m b (T c) -> ProcessT m (b, T c) (Event t) -> (ProcessT m b (T c) -> t -> ProcessT m b (T c)) -> ProcessT m b (T c) Source #

Discrete algebra

Calculations between discrete types.

An example is below.

holdAdd ::
    (Monad m, Num b) =>
    ProcessT m (Event b, Event b) (Discrete b)
holdAdd = proc (evx, evy) ->
  do
    x <- D.hold 0 -< evx
    y <- D.hold 0 -< evy
    D.eval (refer fst + refer snd) -< (x, y)

The last line is equivalent to "arr2 (+) -< (x, y)". Using Alg, you can construct more complex calculations between discrete signals.

newtype Alg m i o Source #

Discrete algebra type.

Constructors

Alg 

Fields

Instances

Monad m => Functor (Alg m i) Source # 

Methods

fmap :: (a -> b) -> Alg m i a -> Alg m i b #

(<$) :: a -> Alg m i b -> Alg m i a #

Monad m => Applicative (Alg m i) Source # 

Methods

pure :: a -> Alg m i a #

(<*>) :: Alg m i (a -> b) -> Alg m i a -> Alg m i b #

liftA2 :: (a -> b -> c) -> Alg m i a -> Alg m i b -> Alg m i c #

(*>) :: Alg m i a -> Alg m i b -> Alg m i b #

(<*) :: Alg m i a -> Alg m i b -> Alg m i a #

(Monad m, Num o) => Num (Alg m i o) Source # 

Methods

(+) :: Alg m i o -> Alg m i o -> Alg m i o #

(-) :: Alg m i o -> Alg m i o -> Alg m i o #

(*) :: Alg m i o -> Alg m i o -> Alg m i o #

negate :: Alg m i o -> Alg m i o #

abs :: Alg m i o -> Alg m i o #

signum :: Alg m i o -> Alg m i o #

fromInteger :: Integer -> Alg m i o #

refer :: Monad m => (e -> T b) -> Alg m e b Source #