Control.Arrow.Machine.Types

Basic types

data ProcessA a b c

The stream transducer arrow.

To construct ProcessA instances, use Plan, arr, functions declared in Utils, or arrow combinations of them.

Instances

(ArrowApply a, ArrowReader r a) => ArrowReader r (ProcessA a)

ArrowApply a => Category * (ProcessA a)

(ArrowApply a, ArrowApply a', ArrowAddReader r a a') => ArrowAddReader r (ProcessA a) (ProcessA a')

ArrowApply a => ArrowChoice (ProcessA a)

ArrowApply a => Arrow (ProcessA a)

(ArrowApply a, ArrowLoop a) => ArrowLoop (ProcessA a)

Arrow a => Profunctor (ProcessA a)

Arrow a => Functor (ProcessA a i)

ArrowApply a => Applicative (ProcessA a i)

class Occasional' a where

Signals that can be absent(NoEvent) or end. For composite structure, collapse can be defined as monoidal sum of all member occasionals.

Methods

collapse :: a -> Event ()

Instances

Occasional' (Event a)

(Occasional' a, Occasional' b) => Occasional' (a, b)

class Occasional' a => Occasional a where

Occasional signals with creation methods.

Methods

noEvent :: a

end :: a

Instances

Occasional (Event a)

(Occasional a, Occasional b) => Occasional (a, b)

data Event a

Instances

Functor Event

Eq a => Eq (Event a)

Show a => Show (Event a)

Semigroup a => Monoid (Event a)

Occasional (Event a)

Occasional' (Event a)

condEvent :: Bool -> Event a -> Event a

filterEvent :: (a -> Bool) -> Event a -> Event a

evMap :: Arrow a => (b -> c) -> a (Event b) (Event c)

Alias of "arr . fmap"

While "ProcessA a (Event b) (Event c)" means a transducer from b to c, function b->c can be lifted into a transducer by fhis function.

But in most cases you needn't call this function in proc-do notations, because arrs are completed automatically while desugaring.

For example,

proc x -> returnA -< f <$> x

is equivalent to

evMap f

Plan monads

type PlanT i o m a = FT (PlanF i o) m a

type Plan i o a = forall m. Monad m => PlanT i o m a

await :: Plan i o i

yield :: o -> Plan i o ()

stop :: Plan i o a

catchP :: Monad m => PlanT i o m a -> PlanT i o m a -> PlanT i o m a

stopped :: (ArrowApply a, Occasional c) => ProcessA a b c

muted :: (ArrowApply a, Occasional' b, Occasional c) => ProcessA a b c

Constructing machines from plans

constructT :: (Monad m, ArrowApply a) => (forall b. m b -> a () b) -> PlanT i o m r -> ProcessA a (Event i) (Event o)

repeatedlyT :: (Monad m, ArrowApply a) => (forall b. m b -> a () b) -> PlanT i o m r -> ProcessA a (Event i) (Event o)

construct :: ArrowApply a => Plan i o t -> ProcessA a (Event i) (Event o)

repeatedly :: ArrowApply a => Plan i o t -> ProcessA a (Event i) (Event o)

Running machines (at once)

run :: ArrowApply a => ProcessA a (Event b) (Event c) -> a [b] [c]

Run a machine.

runOn :: (ArrowApply a, Monoid r, Foldable f) => (c -> r) -> ProcessA a (Event b) (Event c) -> a (f b) r

Run a machine with results concatenated in terms of a monoid.

run_ :: ArrowApply a => ProcessA a (Event b) (Event c) -> a [b] ()

Run a machine discarding all results.

Running machines (step-by-step)

data ExecInfo fa

Represents return values and informations of step executions.

Constructors

ExecInfo

Fields

yields :: fa

hasConsumed :: Bool

hasStopped :: Bool

Instances

Eq fa => Eq (ExecInfo fa)

Show fa => Show (ExecInfo fa)

Alternative f => Monoid (ExecInfo (f a))

stepRun :: ArrowApply a => ProcessA a (Event b) (Event c) -> a b (ExecInfo [c], ProcessA a (Event b) (Event c))

Execute until an input consumed and the machine suspended.

stepYield :: ArrowApply a => ProcessA a (Event b) (Event c) -> a b (ExecInfo (Maybe c), ProcessA a (Event b) (Event c))

Execute until an output produced.

Primitive machines - switches

Switches inspired by Yampa library. Signature is almost same, but collection requirement is not only Functor, but Traversable. This is because of side effects.

switch :: ArrowApply a => ProcessA a b (c, Event t) -> (t -> ProcessA a b c) -> ProcessA a b c

dSwitch :: ArrowApply a => ProcessA a b (c, Event t) -> (t -> ProcessA a b c) -> ProcessA a b c

rSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, Event (ProcessA a b c)) c

drSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, Event (ProcessA a b c)) c

kSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, c) (Event t) -> (ProcessA a b c -> t -> ProcessA a b c) -> ProcessA a b c

dkSwitch :: ArrowApply a => ProcessA a b c -> ProcessA a (b, c) (Event t) -> (ProcessA a b c -> t -> ProcessA a b c) -> ProcessA a b c

pSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a ext c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)

pSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, col c) (Event mng) -> (col (ProcessA a b c) -> mng -> ProcessA a b (col c)) -> ProcessA a b (col c)

rpSwitch :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a (b, Event (col (ProcessA a ext c) -> col (ProcessA a ext c))) (col c)

rpSwitchB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a (b, Event (col (ProcessA a b c) -> col (ProcessA a b c))) (col c)

par :: (ArrowApply a, Traversable col) => (forall sf. b -> col sf -> col (ext, sf)) -> col (ProcessA a ext c) -> ProcessA a b (col c)

parB :: (ArrowApply a, Traversable col) => col (ProcessA a b c) -> ProcessA a b (col c)

Primitive machines - other safe primitives

fit :: (Arrow a, Arrow a') => (forall p q. a p q -> a' p q) -> ProcessA a b c -> ProcessA a' b c

loop' :: ArrowApply a => d -> ProcessA a (b, d) (c, d) -> ProcessA a b c

Primitive machines - unsafe

fitEx :: (Arrow a, Arrow a') => (forall p q. a (p, b) (q, c) -> a' (p, b') (q, c')) -> ProcessA a b c -> ProcessA a' b' c'

unsafeSteady :: ArrowApply a => a b c -> ProcessA a b c

Repeatedly call p.

How many times p is called is indefinite. So p must satisfy the equation below;

p &&& p === p >>> (id &&& id)

unsafeExhaust :: (ArrowApply a, Foldable f) => a b (f c) -> ProcessA a b (Event c)

Repeatedly call p.

How many times p is called is indefinite. So p must satisfy the equation below;

p &&& (p >>> arr null) === p &&& arr (const True)

where

null = getAll . foldMap (_ -> All False)