Pipes.Parse

A Parser is an action that reads from and writes to a stored Producer

Draw one element from the underlying Producer, returning Nothing if the Producer is empty

Skip one element from the underlying Producer, returning True if successful or False if the Producer is empty

skip = fmap isJust draw

Draw all elements from the underlying Producer

Note that drawAll is not an idiomatic use of pipes-parse, but I provide it for simple testing purposes. Idiomatic pipes-parse style consumes the elements immediately as they are generated instead of loading all elements into memory. For example, you can use foldAll or foldAllM for this purpose.

Drain all elements from the underlying Producer

Push back an element onto the underlying Producer

peek checks the first element of the stream, but uses unDraw to push the element back so that it is available for the next draw command.

peek = do
    x <- draw
    case x of
        Nothing -> return ()
        Just a  -> unDraw a
    return x

Check if the underlying Producer is empty

isEndOfInput = fmap isNothing peek

Fold all input values

Control.Foldl.purely foldAll :: Monad m => Fold a b -> Parser a m b

Fold all input values monadically

Control.Foldl.impurely foldAllM :: Monad m => FoldM a m b -> Parser a m b

span is an improper lens that splits the Producer into two Producers, where the outer Producer is the longest consecutive group of elements that satisfy the predicate

splitAt is an improper lens that splits a Producer into two Producers after a fixed number of elements

groupBy splits a Producer into two Producers after the first group of elements that are equal according to the equality predicate

Like groupBy, where the equality predicate is (==)

Convert a Consumer to a Parser

Nothing signifies end of input

Convert a never-ending Consumer to a Parser

Run a Parser repeatedly on a Producer, yielding each `Right result

Returns the remainder of the Producer when the Parser returns Left

Run a Parser repeatedly on a Producer, yielding each Just result

Returns the remainder of the Producer when the Parser returns Nothing

Convert a Parser to a Pipe by running it repeatedly on the input

Variant of parseForever for parsers which return a Maybe instead of an Either

Lift a computation from the argument monad to the constructed monad.

Evaluate a state computation with the given initial state and return the final value, discarding the final state.

• evalStateT m s = liftM fst (runStateT m s)

Evaluate a state computation with the given initial state and return the final state, discarding the final value.

• execStateT m s = liftM snd (runStateT m s)

A state transformer monad parameterized by:

• s - The state.

• m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

Consume the first value from a Producer

next either fails with a Left if the Producer terminates or succeeds with a Right providing the next value and the remainder of the Producer.

Produce a value

yield :: Monad m => a -> Producer a m ()
yield :: Monad m => a -> Pipe   x a m ()

Producers can only yield