Codec.Phaser.Core

Core functions and types.

Documentation

data Automaton p i o a

Represents a nondeterministic computation in progress. There are 4 type parameters: a counter type (may be used for tracking line and column numbers), an input type, an incremental output type, and a final output type.

Instances

Link Phase Automaton Phase

Methods

(>>#) :: Phase p b c x -> Automaton p c t a -> Phase p b t a

Link Automaton Automaton Automaton

Methods

(>>#) :: Automaton p b c x -> Automaton p c t a -> Automaton p b t a

Functor (Automaton p i o)

Methods

fmap :: (a -> b) -> Automaton p i o a -> Automaton p i o b

(<$) :: a -> Automaton p i o b -> Automaton p i o a

data Phase p i o a

A type for building Automaton values. Monad and Applicative instances are defined for this type rather than for Automaton in order to avoid traversing the entire call stack for every input value.

Instances

Link Phase Phase Phase

Methods

(>>#) :: Phase p b c x -> Phase p c t a -> Phase p b t a

Link Phase Automaton Phase

Methods

(>>#) :: Phase p b c x -> Automaton p c t a -> Phase p b t a

Monad (Phase p i o)

Methods

(>>=) :: Phase p i o a -> (a -> Phase p i o b) -> Phase p i o b

(>>) :: Phase p i o a -> Phase p i o b -> Phase p i o b

return :: a -> Phase p i o a

fail :: String -> Phase p i o a

Functor (Phase p i o)

Methods

fmap :: (a -> b) -> Phase p i o a -> Phase p i o b

(<$) :: a -> Phase p i o b -> Phase p i o a

Applicative (Phase p i o)

Methods

pure :: a -> Phase p i o a

(<*>) :: Phase p i o (a -> b) -> Phase p i o a -> Phase p i o b

(*>) :: Phase p i o a -> Phase p i o b -> Phase p i o b

(<*) :: Phase p i o a -> Phase p i o b -> Phase p i o a

Alternative (Phase p i o)

Methods

empty :: Phase p i o a

(<|>) :: Phase p i o a -> Phase p i o a -> Phase p i o a

some :: Phase p i o a -> Phase p i o [a]

many :: Phase p i o a -> Phase p i o [a]

MonadPlus (Phase p i o)

Methods

mzero :: Phase p i o a

mplus :: Phase p i o a -> Phase p i o a -> Phase p i o a

class Link s d l | s d -> l where

Class for types which consume and produce incremental input and output.

Minimal complete definition

(>>#)

Methods

(>>#) :: s p b c x -> d p c t a -> l p b t a infixr 4

Take the incremental output of the first argument and use it as input for the second argument. Discard the final output of the first argument.

Instances

Link Phase Phase Phase

Methods

(>>#) :: Phase p b c x -> Phase p c t a -> Phase p b t a

Link Phase Automaton Phase

Methods

(>>#) :: Phase p b c x -> Automaton p c t a -> Phase p b t a

Link Automaton Automaton Automaton

Methods

(>>#) :: Automaton p b c x -> Automaton p c t a -> Automaton p b t a

get :: Phase p i o i

Return one item of the input.

put :: [i] -> Phase p i o ()

Put a list of values back into the input.

put1 :: i -> Phase p i o ()

Insert one value back into the input. May be used for implementing lookahead

count :: (p -> p) -> Phase p i o ()

Modify the counter

yield :: o -> Phase p i o ()

Yield one item for the incremental output

eof :: Phase p i o ()

Fail if any more input is provided.

(<??>) :: ([String] -> [String]) -> Phase p i o a -> Phase p i o a infixr 1

Warning: ?? is faulty and will be removed in future versions. Please use ? instead

When the right argument fails: apply the left argument to the list of error messages. Depreciated because it doesn't work correctly for all arguments and fixing it would break the Alternative and MonadPlus instances.

(<?>) :: [Char] -> Phase p i o a -> Phase p i o a infixr 1

If parsing fails in the right argument: prepend the left argument to the errors

(>#>) :: ((p0 -> p0) -> p -> p) -> Phase p0 i o a -> Phase p i o a infixr 1

Change the counter type of a Phase object.

starve :: Automaton p i o a -> Automaton p z o a

Remove an Automaton's ability to consume further input

toAutomaton :: Phase p i o a -> Automaton p i o a

Convert a Phase to an Automaton. Subject to fusion.

fromAutomaton :: Automaton p i o a -> Phase p i o a

Convert an Automaton back to a Phase (somewhat inefficient). Subject to fusion.

beforeStep :: Automaton p i o a -> Either (Automaton p v o a) (Automaton p i o a)

Optional pre-processing of an automaton before passing it more input. Produces Right with all "final outputs" and errors stripped if the automaton can accept more input, and Left with everything except errors stripped if it cannot accept more input.

step :: Automaton p i o a -> i -> Automaton p i o a

Pass one input to an automaton

extract :: p -> Automaton p i o a -> Either [(p, [String])] [a]

Take either counters with errors or a list of possible results from an automaton.

toReadS :: Automaton p i o a -> [i] -> [(a, [i])]

Create a ReadS like value from an Automaton. If the Automaton's input type is Char, the result will be ReadS

run :: Automaton p i o a -> [i] -> Automaton p i o a

Pass a list of input values to an Automaton

parse_ :: p -> Phase p i o a -> [i] -> Either [(p, [String])] [a]

Use a Phase value similarly to a parser.

parse1_ :: p -> Phase p i o a -> i -> Either [(p, [String])] [a]

Use a Phase as a parser, but consuming a single input instead of a list

options :: Automaton p i o a -> [Automaton p i o a]

Decompose an Automaton into its component options.

readCount :: Automaton p i o a -> (p -> p, Automaton p i o a)

Separate unconditional counter modifiers from an automaton

outputs :: Automaton p i o a -> ([o], Automaton p i o a)

Separate the values unconditionally yielded by an automaton