Ideas.Common.Strategy.Process

Processes must support choices and sequences. This module defines a type class, an implementation, and utility functions.

IsProcess type class

class (Choice f, Sequence f) => IsProcess f where

Methods

toProcess :: f a -> Process a

Convert to the Process data type.

Instances

IsProcess Builder

IsProcess Process

Process data type

data Process a

This datatype implements choices and sequences, but is slow for building sequences with the <*> combinator. See the Builder data type for a faster alternative.

Instances

Functor Process

Choice Process

Sequence Process

IsProcess Process

Eq a => Eq (Process a)

Firsts (Process a)

type Elem (Process a) = a

menu :: Firsts s => s -> Menu (MenuItem (Elem s) s)

The menu offers single steps (with the remainder) and done steps.

eqProcessBy :: (a -> a -> Bool) -> Process a -> Process a -> Bool

Generalized equality of processes, which takes an equality function for the symbols.

Building sequences

data Builder a

The Builder data type offers a fast implementation for building sequences. The data type implements the IsProcess type class. A Builder value must be converted to a Process (with toProcess) it can be inspected in any way.

Instances

Choice Builder

Sequence Builder

IsProcess Builder

Query functions on a Process

ready :: Firsts s => s -> Bool

The ready predicate (we are done).

stopped :: Firsts s => s -> Bool

Not ready and no further steps to take.

firsts :: Firsts s => s -> [(Elem s, s)]

The first set.

Higher-order functions for iterating over a Process

fold :: Choice f => (a -> f b -> f b) -> f b -> Process a -> f b

Folding over a process takes a function for single steps and for done.

accum :: (a -> b -> [b]) -> b -> Process a -> Menu b

scan :: (s -> a -> [(s, b)]) -> s -> Process a -> Process b

prune :: (a -> Bool) -> Process a -> Process a