Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
- data T a
- updates :: T a -> Event ()
- value :: T a -> a
- arr :: Monad m => (b -> c) -> ProcessT m (T b) (T c)
- arr2 :: Monad m => (b1 -> b2 -> c) -> ProcessT m (T b1, T b2) (T c)
- arr3 :: Monad m => (b1 -> b2 -> b3 -> c) -> ProcessT m (T b1, T b2, T b3) (T c)
- arr4 :: Monad m => (b1 -> b2 -> b3 -> b4 -> c) -> ProcessT m (T b1, T b2, T b3, T b4) (T c)
- arr5 :: Monad m => (b1 -> b2 -> b3 -> b4 -> b5 -> c) -> ProcessT m (T b1, T b2, T b3, T b4, T b5) (T c)
- constant :: Monad m => c -> ProcessT m b (T c)
- unsafeConstant :: Monad m => c -> ProcessT m b (T c)
- hold :: Monad m => b -> ProcessT m (Event b) (T b)
- accum :: Monad m => b -> ProcessT m (Event (b -> b)) (T b)
- fromEq :: (Monad m, Eq b) => ProcessT m b (T b)
- edge :: Monad m => ProcessT m (T b) (Event b)
- asUpdater :: Monad m => (b -> m c) -> ProcessT m (T b) (Event c)
- 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)
- 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)
- newtype Alg m i o = Alg {}
- refer :: Monad m => (e -> T b) -> Alg m e b
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.
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 #
unsafeConstant :: Monad m => c -> ProcessT m b (T c) Source #
Constant without initial notifications. Users must manage initialization manually.
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.
Discrete algebra type.