Control.Arrow.Machine.Types

Stream transducer type

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.

See an introduction at Control.Arrow.Machine documentation.

Instances

ArrowApply a => ArrowChoice (ProcessA a)

Methods

left :: ProcessA a b c -> ProcessA a (Either b d) (Either c d)

right :: ProcessA a b c -> ProcessA a (Either d b) (Either d c)

(+++) :: ProcessA a b c -> ProcessA a b' c' -> ProcessA a (Either b b') (Either c c')

(|||) :: ProcessA a b d -> ProcessA a c d -> ProcessA a (Either b c) d

ArrowApply a => Arrow (ProcessA a)

Methods

arr :: (b -> c) -> ProcessA a b c

first :: ProcessA a b c -> ProcessA a (b, d) (c, d)

second :: ProcessA a b c -> ProcessA a (d, b) (d, c)

(***) :: ProcessA a b c -> ProcessA a b' c' -> ProcessA a (b, b') (c, c')

(&&&) :: ProcessA a b c -> ProcessA a b c' -> ProcessA a b (c, c')

ArrowApply a => ArrowLoop (ProcessA a)

Methods

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

ArrowApply a => Profunctor (ProcessA a)

Methods

dimap :: (a -> b) -> (c -> d) -> ProcessA a b c -> ProcessA a a d

lmap :: (a -> b) -> ProcessA a b c -> ProcessA a a c

rmap :: (b -> c) -> ProcessA a a b -> ProcessA a a c

(#.) :: Coercible * c b => (b -> c) -> ProcessA a a b -> ProcessA a a c

(.#) :: Coercible * b a => ProcessA a b c -> (a -> b) -> ProcessA a a c

ArrowApply a => Category * (ProcessA a)

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

ArrowApply a => Functor (ProcessA a i)

Methods

fmap :: (a -> b) -> ProcessA a i a -> ProcessA a i b

(<$) :: a -> ProcessA a i b -> ProcessA a i a

ArrowApply a => Applicative (ProcessA a i)

Methods

pure :: a -> ProcessA a i a

(<*>) :: ProcessA a i (a -> b) -> ProcessA a i a -> ProcessA a i b

(*>) :: ProcessA a i a -> ProcessA a i b -> ProcessA a i b

(<*) :: ProcessA a i a -> ProcessA a i b -> ProcessA a i a

Event type and utility

class Occasional' a where

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

Minimal complete definition

collapse

Methods

collapse :: a -> Event ()

Instances

Occasional' (Event a)

Methods

collapse :: Event a -> Event ()

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

Methods

collapse :: (a, b) -> Event ()

class Occasional' a => Occasional a where

Occasional signals with creation methods.

Minimal complete definition

noEvent, end

Methods

noEvent :: a

end :: a

Instances

Occasional (Event a)

Methods

noEvent :: Event a

end :: Event a

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

Methods

noEvent :: (a, b)

end :: (a, b)

data Event a

Discrete events on a time line. Created and consumed by various transducers.

Instances

Functor Event

Methods

fmap :: (a -> b) -> Event a -> Event b

(<$) :: a -> Event b -> Event a

Semigroup a => Monoid (Event a)

Methods

mempty :: Event a

mappend :: Event a -> Event a -> Event a

mconcat :: [Event a] -> Event a

Occasional (Event a)

Methods

noEvent :: Event a

end :: Event a

Occasional' (Event a)

Methods

collapse :: Event a -> Event ()

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

filterEvent :: Arrow ar => (a -> Bool) -> ar (Event a) (Event a)

filterJust :: Arrow ar => ar (Event (Maybe a)) (Event a)

filterLeft :: Arrow ar => ar (Event (Either a b)) (Event a)

filterRight :: Arrow ar => ar (Event (Either a b)) (Event b)

splitEvent :: Arrow ar => ar (Event (Either a b)) (Event a, Event b)

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

Coroutine monad

Procedural coroutine monad that can await or yield values.

Coroutines can be encoded to machines by constructT or so on and then put into ProcessA compositions.

newtype PlanT i o m a

Constructors

PlanT

Fields

• freePlanT :: FT (PlanF i o) m a

Instances

MonadReader r m => MonadReader r (PlanT i o m)

Methods

ask :: PlanT i o m r

local :: (r -> r) -> PlanT i o m a -> PlanT i o m a

reader :: (r -> a) -> PlanT i o m a

MonadState s m => MonadState s (PlanT i o m)

Methods

get :: PlanT i o m s

put :: s -> PlanT i o m ()

state :: (s -> (a, s)) -> PlanT i o m a

MonadWriter w m => MonadWriter w (PlanT i o m)

Methods

writer :: (a, w) -> PlanT i o m a

tell :: w -> PlanT i o m ()

listen :: PlanT i o m a -> PlanT i o m (a, w)

pass :: PlanT i o m (a, w -> w) -> PlanT i o m a

MonadTrans (PlanT i o)

Methods

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

Monad (PlanT i o m)

Methods

(>>=) :: PlanT i o m a -> (a -> PlanT i o m b) -> PlanT i o m b

(>>) :: PlanT i o m a -> PlanT i o m b -> PlanT i o m b

return :: a -> PlanT i o m a

fail :: String -> PlanT i o m a

Functor (PlanT i o m)

Methods

fmap :: (a -> b) -> PlanT i o m a -> PlanT i o m b

(<$) :: a -> PlanT i o m b -> PlanT i o m a

Applicative (PlanT i o m)

Methods

pure :: a -> PlanT i o m a

(<*>) :: PlanT i o m (a -> b) -> PlanT i o m a -> PlanT i o m b

(*>) :: PlanT i o m a -> PlanT i o m b -> PlanT i o m b

(<*) :: PlanT i o m a -> PlanT i o m b -> PlanT i o m a

Alternative m => Alternative (PlanT i o m)

Methods

empty :: PlanT i o m a

(<|>) :: PlanT i o m a -> PlanT i o m a -> PlanT i o m a

some :: PlanT i o m a -> PlanT i o m [a]

many :: PlanT i o m a -> PlanT i o m [a]

(Monad m, Alternative m) => MonadPlus (PlanT i o m)

Methods

mzero :: PlanT i o m a

mplus :: PlanT i o m a -> PlanT i o m a -> PlanT 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 => PlanT i o Identity r -> ProcessA a (Event i) (Event o)

repeatedly :: ArrowApply a => PlanT i o Identity r -> 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

  Values yielded while the step.

• hasConsumed :: Bool

  True if the input value is consumed.

  False if the machine has stopped unless consuming the input.

  Or in the case of stepYield, this field become false when the machine produces a value unless consuming the input.

• hasStopped :: Bool

  True if the machine has stopped at the end of the step.

Instances

Eq fa => Eq (ExecInfo fa)

Methods

(==) :: ExecInfo fa -> ExecInfo fa -> Bool

(/=) :: ExecInfo fa -> ExecInfo fa -> Bool

Show fa => Show (ExecInfo fa)

Methods

showsPrec :: Int -> ExecInfo fa -> ShowS

show :: ExecInfo fa -> String

showList :: [ExecInfo fa] -> ShowS

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

Methods

mempty :: ExecInfo (f a)

mappend :: ExecInfo (f a) -> ExecInfo (f a) -> ExecInfo (f a)

mconcat :: [ExecInfo (f a)] -> 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 suspends.

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

gSwitch :: ArrowApply a => ProcessA a b (p, r) -> ProcessA a p q -> ProcessA a (q, r) (c, Event t) -> (ProcessA a p q -> t -> ProcessA a b c) -> ProcessA a b c

dgSwitch :: ArrowApply a => ProcessA a b (p, r) -> ProcessA a p q -> ProcessA a (q, r) (c, Event t) -> (ProcessA a p q -> 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)

dpSwitch :: (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)

dpSwitchB :: (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)

drpSwitch :: (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)

drpSwitchB :: (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 :: (ArrowApply a, ArrowApply a') => (forall p q. a p q -> a' p q) -> ProcessA a b c -> ProcessA a' b c

Natural transformation

fitW :: (ArrowApply a, ArrowApply a', Functor w) => (forall p. w p -> p) -> (forall p q. a p q -> a' (w p) q) -> ProcessA a b c -> ProcessA a' (w b) c

Experimental: more general fit.

Should w be a comonad?

Primitive machines - unsafe

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)