An effectful automaton in initial encoding.

• m: The monad in which the automaton performs side effects.
• a: The type of inputs the automaton constantly consumes.
• b: The type of outputs the automaton constantly produces.

An effectful automaton with input a is the same as an effectful stream with the additional effect of reading an input value a on every step. This is why automata are defined here as streams.

The API of automata follows that of streams (StreamT and OptimizedStreamT) closely. The prominent addition in automata is now that they are instances of the Category, Arrow, Profunctor, and related type classes. This allows for more ways of creating or composing them.

For example, you can sequentially and parallely compose two automata: @ automaton1 :: Automaton m a b automaton2 :: Automaton m b c

sequentially :: Automaton m a c sequentially = automaton1 >>> automaton2

parallely :: Automaton m (a, b) (b, c) parallely = automaton1 *** automaton2 @ In sequential composition, the output of the first automaton is passed as input to the second one. In parallel composition, both automata receive input simulataneously and process it independently.

Through the Arrow type class, you can use arr to create an automaton from a pure function, and more generally use the arrow syntax extension to define automata.

Create an Automaton from a state and a pure step function.

Create an Automaton from a state and an effectful step function.

Consume an input and produce output effectfully, without keeping internal state

Produce output effectfully, without keeping internal state

Apply an arbitrary monad morphism to an automaton.

Lift the monad of an automaton to a transformer.

Extend the internal state and feed back part of the output to the next input.

This is one of the fundamental ways to incorporate recursive dataflow in automata. Given an automaton which consumes an additional input and produces an additional output, the state of the automaton is extended by a further value. This value is used as the additional input, and the resulting additional output is stored in the internal state for the next step.

Run one step of an automaton.

This consumes an input value, performs a side effect, and returns an updated automaton together with an output value.

Run an automaton with trivial input and output indefinitely.

If the input and output of an automaton does not contain information, all of its meaning is in its effects. This function runs the automaton indefinitely. Since it will never return with a value, this function also has no output (its output is void). The only way it can return is if m includes some effect of termination, e.g. Maybe or Either could terminate with a Nothing or Left value, or IO can raise an exception.

Run an automaton with given input, for a given number of steps.

Especially for tests and batch processing, it is useful to step an automaton with given input.

Change the output type and effect of an automaton without changing its state type.

Only step the automaton if the input is Just.

Use an Automaton with a variable amount of input.

Like traverseS, discarding the output.

Launch arbitrarily many copies of the automaton in parallel.

• The copies of the automaton are launched on demand as the input lists grow.
• The n-th copy will always receive the n-th input.
• If the input list has length n, the n+1-th automaton copy will not be stepped.

Caution: Uses memory of the order of the largest list that was ever input during runtime.

Given a transformation of streams, apply it to an automaton, without changing the input.

Given a transformation of streams, apply it to an automaton. The input can be accessed through the ReaderT effect.

Buffer the output of an automaton. See concatS.

Pass through a value unchanged, and perform a side effect depending on it

Accumulate the input, output the accumulator.

Like accumulateWith, with mappend as the accumulation function.

Delay the input by one step.

Delay an automaton by one step by prepending one value to the output.

On the first step, the given initial output is returned. On all subsequent steps, the automaton is stepped with the previous input.

Like mappendFrom, initialised at mempty.

Sum up all inputs so far, with an explicit initial value.

Like sumFrom, initialised at 0.

Sum up all inputs so far, initialised at 0.

Count the natural numbers, beginning at 1.

Remembers the last Just value, defaulting to the given initialisation value.