An effectful automaton in coalgebraic 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

inParallel :: Automaton m (a, b) (b, c) inParallel = 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.

Like unfold, but output the current state.

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 input and output type and effect of an automaton without changing its state type.

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.

Launch many copies of the automaton in parallel, depending on the input shape.

• This generalises parallelyList from lists to arbitrary Witherables satisfying Align such as Maps, Seq'uences, and other data structures.
• The copies of the automaton are launched on demand as the input shape changes in such a way that there are new positions.
• The automaton copy on a particular position will always receive the input from that position.
• Only those automaton copies on positions with a matching input will be stepped.

For example, if the first input is a map with keys k1 and k2, two copies will be started, one for each key. If the next input map has keys k1 and k3, the first automaton at key k1 will be stepped, the copy at k2 will not be stepped and keeps its state, and a new copy will be launched at k3.

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

Create an Automaton from a stream.

It will ignore its input.

Create a StreamT from an Automaton.

The resulting stream can read the current input as an effect in ReaderT.

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

Like handleAutomaton_, but with fewer constraints.

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.

The input for the automaton is not buffered. For example, if concatS automaton receives one input a and automaton produces 10 bs from it, then the next 9 inputs will be ignored.

Continuously interpret a first order effect.

Several types are relevant here:

• sig: An effect signature functor, that encodes one effect. For example, Either e for raising exceptions of type e, or (w, ) for a logging effect.
• eff: A monad that carries the effect. This can be a monad transformer stack including a transformer corresponding to sig, such as ExceptT for Either. It can also be the Eff monad of an effect library such as polysemy, bluefin, effectful and so on.
• m: The underlying monad in which the interpretation is performed, think "eff without the effects from sig".

This function takes two functions, one to create effects in eff from the signature, and the other to fully interpret them in m, storing the complete effect information in sig again. It then executes the given automaton, extracting the effect by interpretation, and sending it back in. The execution semantics is that of the monad eff, while the pure effect of the whole computation is returned in the output, encoded in sig.

For examples, see handleEffect.

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.

The new values are mappended from the left.

Like mappendFrom, but mappending new values from the right.

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.

Call the monadic action once on the first tick and provide its result indefinitely.

Like initialised, but ignores the input.