Foundation.Parser

The current implementation is mainly, if not copy/pasted, inspired from memory's Parser.

Foundation Parser makes use of the Foundation's Collection and Sequential classes to allow you to define generic parsers over any Sequential of inpu.

This way you can easily implements parsers over LString, String.

flip parseOnly "[e-mail]" $ do
   EmailAddress
     <$> (takeWhile ((/=) '@' <*  element '@')
     <*> takeAll

Documentation

data Parser input result

Foundation's Parser monad.

Its implementation is based on the parser in memory.

Instances

ParserSource input => Monad (Parser input)

Methods

(>>=) :: Parser input a -> (a -> Parser input b) -> Parser input b

(>>) :: Parser input a -> Parser input b -> Parser input b

return :: a -> Parser input a

fail :: String -> Parser input a

Functor (Parser input)

Methods

fmap :: (a -> b) -> Parser input a -> Parser input b

(<$) :: a -> Parser input b -> Parser input a

ParserSource input => Applicative (Parser input)

Methods

pure :: a -> Parser input a

(<*>) :: Parser input (a -> b) -> Parser input a -> Parser input b

(*>) :: Parser input a -> Parser input b -> Parser input b

(<*) :: Parser input a -> Parser input b -> Parser input a

ParserSource input => Alternative (Parser input)

Methods

empty :: Parser input a

(<|>) :: Parser input a -> Parser input a -> Parser input a

some :: Parser input a -> Parser input [a]

many :: Parser input a -> Parser input [a]

ParserSource input => MonadPlus (Parser input)

Methods

mzero :: Parser input a

mplus :: Parser input a -> Parser input a -> Parser input a

parse :: ParserSource input => Parser input a -> input -> Result input a

Run a Parser on a ByteString and return a Result

parseFeed :: (ParserSource input, Monad m) => m (Chunk input) -> Parser input a -> input -> m (Result input a)

Run a parser on an @initial input.

If the Parser need more data than available, the @feeder function is automatically called and fed to the More continuation.

parseOnly :: (ParserSource input, Monoid (Chunk input)) => Parser input a -> input -> Either (ParseError input) a

parse only the given input

The left-over `Element input` will be ignored, if the parser call for more data it will be continuously fed with Nothing (up to 256 iterations).

Result

data Result input result

result of executing the parser over the given input

Constructors

ParseFailed (ParseError input)

the parser failed with the given ParserError

ParseOk (Chunk input) result

the parser complete successfuly with the remaining Chunk

ParseMore (Chunk input -> Result input result)

the parser needs more input, pass an empty Chunk or mempty to tell the parser you don't have anymore inputs.

Instances

Functor (Result input)

Methods

fmap :: (a -> b) -> Result input a -> Result input b

(<$) :: a -> Result input b -> Result input a

Show k => Show (Result input k)

Methods

showsPrec :: Int -> Result input k -> ShowS

show :: Result input k -> String

showList :: [Result input k] -> ShowS

data ParseError input

common parser error definition

Constructors

NotEnough (CountOf (Element input))

meaning the parser was short of CountOf Element of input.

NotEnoughParseOnly

The parser needed more data, only when using parseOnly

ExpectedElement (Element input) (Element input)

when using element

Expected (Chunk input) (Chunk input)

when using elements or string

Satisfy (Maybe String)

the satisfy or satisfy_ function failed,

Instances

Show (ParseError input)

Methods

showsPrec :: Int -> ParseError input -> ShowS

show :: ParseError input -> String

showList :: [ParseError input] -> ShowS

Typeable * input => Exception (ParseError input)

Methods

toException :: ParseError input -> SomeException

fromException :: SomeException -> Maybe (ParseError input)

displayException :: ParseError input -> String

Parser source

class (Sequential input, IndexedCollection input) => ParserSource input where

Minimal complete definition

nullChunk, appendChunk, subChunk, spanChunk

Associated Types

type Chunk input

Methods

nullChunk :: input -> Chunk input -> Bool

appendChunk :: input -> Chunk input -> input

subChunk :: input -> Offset (Element input) -> CountOf (Element input) -> Chunk input

spanChunk :: input -> Offset (Element input) -> (Element input -> Bool) -> (Chunk input, Offset (Element input))

Instances

ParserSource String

Associated Types

type Chunk String :: *

Methods

nullChunk :: String -> Chunk String -> Bool

appendChunk :: String -> Chunk String -> String

subChunk :: String -> Offset (Element String) -> CountOf (Element String) -> Chunk String

spanChunk :: String -> Offset (Element String) -> (Element String -> Bool) -> (Chunk String, Offset (Element String))

ParserSource [a]

Associated Types

type Chunk [a] :: *

Methods

nullChunk :: [a] -> Chunk [a] -> Bool

appendChunk :: [a] -> Chunk [a] -> [a]

subChunk :: [a] -> Offset (Element [a]) -> CountOf (Element [a]) -> Chunk [a]

spanChunk :: [a] -> Offset (Element [a]) -> (Element [a] -> Bool) -> (Chunk [a], Offset (Element [a]))

combinator

element :: (ParserSource input, Eq (Element input), Element input ~ Element (Chunk input)) => Element input -> Parser input ()

anyElement :: ParserSource input => Parser input (Element input)

Get the next `Element input` from the parser

elements :: (ParserSource input, Sequential (Chunk input), Element (Chunk input) ~ Element input, Eq (Chunk input)) => Chunk input -> Parser input ()

string :: String -> Parser String ()

satisfy :: ParserSource input => Maybe String -> (Element input -> Bool) -> Parser input (Element input)

take one element if satisfy the given predicate

satisfy_ :: ParserSource input => (Element input -> Bool) -> Parser input (Element input)

take one element if satisfy the given predicate

take :: (ParserSource input, Sequential (Chunk input), Element input ~ Element (Chunk input)) => CountOf (Element (Chunk input)) -> Parser input (Chunk input)

takeWhile :: (ParserSource input, Sequential (Chunk input)) => (Element input -> Bool) -> Parser input (Chunk input)

takeAll :: (ParserSource input, Sequential (Chunk input)) => Parser input (Chunk input)

Take the remaining elements from the current position in the stream

skip :: ParserSource input => CountOf (Element input) -> Parser input ()

skipWhile :: (ParserSource input, Sequential (Chunk input)) => (Element input -> Bool) -> Parser input ()

skipAll :: (ParserSource input, Collection (Chunk input)) => Parser input ()

consume every chunk of the stream

(<|>) :: Alternative f => forall a. f a -> f a -> f a

An associative binary operation

many :: Alternative f => forall a. f a -> f [a]

Zero or more.

some :: Alternative f => forall a. f a -> f [a]

One or more.

optional :: Alternative f => f a -> f (Maybe a)

One or none.

repeat :: ParserSource input => Condition -> Parser input a -> Parser input [a]

repeat the given parser a given amount of time

Unlike some or many, this operation will bring more precision on how many times you wish a parser to be sequenced.

## Repeat Exactly a number of time

repeat (Exactly 6) (takeWhile ((/=) ',') <* element ',')

## Repeat Between lower `@And@` upper times

repeat (Between $ 1 `And` 10) (takeWhile ((/=) ',') <* element ',')

data Condition

Constructors

Between !And

Exactly !Word

Instances

Eq Condition

Methods

(==) :: Condition -> Condition -> Bool

(/=) :: Condition -> Condition -> Bool

Show Condition

Methods

showsPrec :: Int -> Condition -> ShowS

show :: Condition -> String

showList :: [Condition] -> ShowS

data And

Constructors

And !Word !Word

Instances

Eq And

Methods

(==) :: And -> And -> Bool

(/=) :: And -> And -> Bool

Show And

Methods

showsPrec :: Int -> And -> ShowS

show :: And -> String

showList :: [And] -> ShowS