Module Data.MicroParsec

Small parser, inspired by Parsec, but much less versatile. A bit faster and uses less memory than the transformer in Data.NanoParsec.

Imports

• import Data.Iterators as Iterators
• import frege.Prelude as Prelude
• import Prelude.PreludeArrays as PreludeArrays
• import Prelude.PreludeBase as PreludeBase
• import Prelude.PreludeDecimal as PreludeDecimal
• import Prelude.PreludeIO as PreludeIO
• import Prelude.PreludeList as PreludeList
• import Prelude.PreludeMonad as PreludeMonad
• import Prelude.PreludeText as PreludeText
• import Java.util.Regex as Regexp

Table of Content

• Definitions

  data Parser s t r

  getPos ∷ Parser α β (α β)

  putPos ∷ α β → Parser α β ()

  modifyPos ∷ (α β→α β) → Parser α β ()

  failure ∷ String → Parser α β γ

  runid ∷ Parser α β γ → α β → ((String | γ), α β)

  parse ∷ Parser α β γ → α β → (String | γ)

  parseTest ∷ (Show r, Show t, ListView s) ⇒ Parser s t r → s t → IO ()

  reporterror ∷ (ListSource β, Show α) ⇒ β α → String → String

  label ∷ String → Parser γ β α → Parser γ β α

  <?> ∷ Parser γ β α → String → Parser γ β α 

  expect ∷ (Show β, Eq β, ListView α) ⇒ β → Parser α β β

  eos ∷ ListView α ⇒ Parser α β ()

  satisfy ∷ ListView s ⇒ (t → Bool) → Parser s t t

  exceptWhen ∷ ListView α ⇒ (β→Bool) → Parser α β ()

  pany ∷ ListView α ⇒ Parser α β β

  symbol ∷ ListView β ⇒ Parser β Char α → Parser β Char α

  space ∷ ListView α ⇒ Parser α Char Char

  digit ∷ ListView α ⇒ Parser α Char Char

  letter ∷ ListView α ⇒ Parser α Char Char

  uppercase ∷ ListView α ⇒ Parser α Char Char

  spaces ∷ ListView α ⇒ Parser α Char ()

  string ∷ String → Parser StringIterator Char String

  match ∷ Regex → Parser StringIterator Char MatchResult

  optional ∷ Parser s t r → Parser s t (Maybe r)

  many ∷ Parser γ β α → Parser γ β [α]

  some ∷ Parser γ β α → Parser γ β [α]

  many1 ∷ Parser γ β α → Parser γ β [α]

  skip ∷ Parser β δ γ → Parser β δ ()

  manyWhile ∷ ListView β ⇒ (α→Bool) → Parser β α [α]

  skipWhile ∷ ListView α ⇒ (β→Bool) → Parser α β ()

  skipUntil ∷ ListView β ⇒ (α→Bool) → Parser β α ()

  cond ∷ Parser β γ α → Parser β γ δ → Parser β γ δ → Parser β γ δ

  select ∷ [(Parser a d b, Parser a d c)] → Parser a d c → Parser a d c

  choice ∷ Plus β ⇒ [β α] → β α

  count ∷ Monad β ⇒ Int → β α → β [α]

  between ∷ Monad α ⇒ α β → α δ → α γ → α γ

  option ∷ α → Parser γ β α → Parser γ β α

  sepBy1 ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

  sepBy ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

  endBy ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

  endBy1 ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

  sepEndBy ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

  sepEndBy1 ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

• Instances

  instance MonadAlt (Parser s t)

• Functions and Values by Type

Definitions

data Parser s t r

Parser Monad

 Parser s t r

is the type of parsers that reads tokens of type t from a stream s t and returns either an error message string or a result r paired with the yet unprocessed input.

Works in principle like a combination of State and Either, where the state is the current input to get parsed, and the bind operations will stop on the first Either.Left result, which signals a syntax error.

Parser is also an instance of MonadAlt. The operations MonadAlt.<+> and Alt.<|> can be used to implement choice, i.e. they allow to continue on failure.

The input for a Parser must be something that is an instance of ListView. Ordinary lists, Strings, StringIterator and ArrayIterator are such types. The parser combinators use only the ListView.uncons and ListEmpty.null operations.

Constructors

private P {run ∷ s t → ((String | r), s t)}

Member Functions

run ∷ Parser α β γ → α β → ((String | γ), α β)

access field run

getPos ∷ Parser α β (α β)

Remember the current state of the input stream.

getPos always succeeds.

putPos ∷ α β → Parser α β ()

Resume parsing with the given input stream.

putPos always succeeds.

modifyPos ∷ (α β→α β) → Parser α β ()

failure ∷ String → Parser α β γ

fail with given error message

runid ∷ Parser α β γ → α β → ((String | γ), α β)

run a parser

parse ∷ Parser α β γ → α β → (String | γ)

run a Parser, return just the result/error

parseTest ∷ (Show r, Show t, ListView s) ⇒ Parser s t r → s t → IO ()

run a Parser on some input and report

reporterror ∷ (ListSource β, Show α) ⇒ β α → String → String

label ∷ String → Parser γ β α → Parser γ β α

Causes the error message to be msg when p fails.

The error will be reported at the position where p was attempted, not necessarily at the position where p failed:

 Parser.run (letter >> digit) "a?"
 unexpected token, found ?
 Parser.run (label "id expected" $ letter >> digit) "a?"
 id expected, found a?

<?> ∷ Parser γ β α → String → Parser γ β α
infix  14

 p <?> msg

Causes the error message to be msg when p fails.

The error will be reported at the position where p failed.

expect ∷ (Show β, Eq β, ListView α) ⇒ β → Parser α β β

 expect t

This parser succeeds if the input is not empty and the head of the input equals t.

eos ∷ ListView α ⇒ Parser α β ()

The eos parser succeeds if the input is empty.

satisfy ∷ ListView s ⇒ (t → Bool) → Parser s t t

 satisfy property

Succeeds if there is a next token t and property t is true.

exceptWhen ∷ ListView α ⇒ (β→Bool) → Parser α β ()

 exceptWhen prop

Fails if and only if there is a next token t and prop t is true.

Succeeds on end of stream or when the token does not satisfy the property.

In other words, exceptWhen p succeeds if and only if satisfy p fails.

pany ∷ ListView α ⇒ Parser α β β

 pany

Fails if and only if eos succeeds, otherwise returns the next token.

symbol ∷ ListView β ⇒ Parser β Char α → Parser β Char α

 symbol p

Is the same parser as p, but skips spaces afterwards

space ∷ ListView α ⇒ Parser α Char Char

parse a single space character

digit ∷ ListView α ⇒ Parser α Char Char

parse a single digit

letter ∷ ListView α ⇒ Parser α Char Char

parse a single letter

uppercase ∷ ListView α ⇒ Parser α Char Char

parse a single uppercase letter

spaces ∷ ListView α ⇒ Parser α Char ()

skip any spaces

string ∷ String → Parser StringIterator Char String

match ∷ Regex → Parser StringIterator Char MatchResult

This parser succeeds if the pattern matches the beginning of the string.

For efficiency reasons, the pattern should start with ^

optional ∷ Parser s t r → Parser s t (Maybe r)

The optional parser always succeeds and returns its result wrapped in Maybe

many ∷ Parser γ β α → Parser γ β [α]

 many p

Collects as many p as possible and returns the results in a list.

Succeeds also when p fails the first time, in that case the result is an empty list.

Must not be applied to a parser that always succeeds!

some ∷ Parser γ β α → Parser γ β [α]

 some p

Like many, except there must be at least one p

Must not be applied to a parser that always succeeds!

many1 ∷ Parser γ β α → Parser γ β [α]

Alias for some

skip ∷ Parser β δ γ → Parser β δ ()

 skip p

equivalent to

 many p >> return ()

but faster, because it does not build up lists.

Must not be applied to a parser that always succeeds!

manyWhile ∷ ListView β ⇒ (α→Bool) → Parser β α [α]

 manyWhile p

Collect tokens as long as they satisfy p

skipWhile ∷ ListView α ⇒ (β→Bool) → Parser α β ()

 skipWhile p

Skip tokens as long as they satisfy predicate p.

Beware of negative predicates like

 skipWhile (!= 'a')

This will loop forever if there is no 'a' in the input stream. Instead use

 skipUntil (== 'a')

skipUntil ∷ ListView β ⇒ (α→Bool) → Parser β α ()

 skipUntil p

Skip tokens as long as they do not satisfy p

When this succeeds, the next token will satisfy p or the stream is exhausted.

cond ∷ Parser β γ α → Parser β γ δ → Parser β γ δ → Parser β γ δ

 cond pcond pthen pelse

if pcond succeeds, then pthen is run, else pelse

To both pthen and pelse it will appear as if pcond didn't consume any tokens.

select ∷ [(Parser a d b, Parser a d c)] → Parser a d c → Parser a d c

 select [(if1, t1), (if2, t2), ..., (ifn, tn)] e

unfolds as

 cond if1 t1 (cond if2 t2 (... (cond ifn tn e)))    

choice ∷ Plus β ⇒ [β α] → β α

 choice ps

Tries the parsers in the list from left to right, until success.

count ∷ Monad β ⇒ Int → β α → β [α]

 count n p

Applies p n times and returns a list of the results

between ∷ Monad α ⇒ α β → α δ → α γ → α γ

 between left right p

Parses left, then p and finally right and returns the result of p

option ∷ α → Parser γ β α → Parser γ β α

 option v p

Applies p, and returns v when it fails.

Always succeeds.

sepBy1 ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

 p `sepBy1` q

Parses p and many q followed by p

sepBy ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

 p `sepBy` q

Like sepBy1, but allows zero p elements

endBy ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

 p `endBy` q

Parses zero or more occurrences of p separated and ended by q

endBy1 ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

 p `endBy1` q

Parses one or more occurrences of p separated and ended by q

sepEndBy ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

 p `sepEndBy` q

Parses zero or more occurrences of p, separated and optionally ended by q

sepEndBy1 ∷ Parser δ γ α → Parser δ γ β → Parser δ γ [α]

 p `sepEndBy1` q

Parses one or more occurrences of p, separated and optionally ended by q

Instances

instance MonadAlt (Parser s t)

Member Functions

*> ∷ Parser β α γ → Parser β α δ → Parser β α δ
infixl  4

<* ∷ Parser β α γ → Parser β α δ → Parser β α γ
infixl  4

<*> ∷ Parser β α (γ→δ) → Parser β α γ → Parser β α δ
infixl  4

inherited from Monad.<*>

<+> ∷ Parser β α γ → Parser β α γ → Parser β α γ
infixr  13

 p <+> q

The result is that of the first parser, if it succeeds, otherwise that of the second one, which is applied to the input left over by p

<|> ∷ Parser β α γ → Parser β α γ → Parser β α γ
infixl  3

 p <|> q

The result is that of the first parser, if it succeeds, otherwise that of the second one. Note that q is run on the same input as p, even if p already consumed something.

 expect 'c' <|> expect 'd'

would succeed if the input starts with 'c' or 'd'.

>> ∷ Parser β α γ → Parser β α δ → Parser β α δ
infixl  3

inherited from Monad.>>

>>= ∷ Parser β α γ → (γ → Parser β α δ) → Parser β α δ
infixl  3

 p >>= (r -> q)
 p >> q

If p succeeds, the overall result is that of q Otherwise, the overall result is failure.

Could be read as p followed by q.

fmap ∷ (γ → δ) → Parser β α γ → Parser β α δ
infixl  4

inherited from Monad.fmap

join ∷ Parser β α (Parser β α γ) → Parser β α γ

inherited from Monad.join

pure ∷ γ → Parser β α γ

generic success

pzero ∷ Parser β α γ

generic failure

Functions and Values by Type

String → Parser StringIterator Char String

string

Regex → Parser StringIterator Char MatchResult

match

α → Bool

Parser.has$run

ListView α ⇒ Parser α Char ()

spaces

ListView α ⇒ Parser α Char Char

digit, letter, space, uppercase

(α β→α β) → Parser α β ()

modifyPos

α β → Parser α β ()

putPos

(ListSource β, Show α) ⇒ β α → String → String

reporterror

ListView s ⇒ (t → Bool) → Parser s t t

satisfy

ListView α ⇒ (β→Bool) → Parser α β ()

exceptWhen, skipWhile

ListView β ⇒ Parser β Char α → Parser β Char α

symbol

ListView β ⇒ (α→Bool) → Parser β α [α]

manyWhile

ListView β ⇒ (α→Bool) → Parser β α ()

skipUntil

Monad β ⇒ Int → β α → β [α]

count

Plus β ⇒ [β α] → β α

choice

(Show β, Eq β, ListView α) ⇒ β → Parser α β β

expect

Parser α β (α β)

getPos

ListView α ⇒ Parser α β ()

eos

ListView α ⇒ Parser α β β

pany

(s t → ((String | r), s t)) → Parser s t r

Parser.P

Parser s t r → Parser s t (Maybe r)

optional

Parser α β γ → α β → ((String | γ), α β)

runid, Parser.run

Parser α β γ → α β → (String | γ)

parse

Parser β α (Parser β α γ) → Parser β α γ

MonadAlt_Parser.join

Parser β α γ → Parser β α γ → Parser β α γ

MonadAlt_Parser.<|>, MonadAlt_Parser.<+>

Parser β δ γ → Parser β δ ()

skip

Parser γ β α → String → Parser γ β α

<?>

Parser γ β α → Parser γ β [α]

many, some

String → Parser γ β α → Parser γ β α

label

String → Parser α β γ

failure

α → Parser γ β α → Parser γ β α

option

γ → Parser β α γ

MonadAlt_Parser.pure

(Show r, Show t, ListView s) ⇒ Parser s t r → s t → IO ()

parseTest

Parser β α γ

MonadAlt_Parser.pzero

(γ → δ) → Parser β α γ → Parser β α δ

MonadAlt_Parser.fmap

Parser β α (γ→δ) → Parser β α γ → Parser β α δ

MonadAlt_Parser.<*>

Parser β α γ → (γ → Parser β α δ) → Parser β α δ

MonadAlt_Parser.>>=

Parser β α γ → Parser β α δ → Parser β α γ

MonadAlt_Parser.<*

Parser β α γ → Parser β α δ → Parser β α δ

MonadAlt_Parser.>>, MonadAlt_Parser.*>

Parser β γ α → Parser β γ δ → Parser β γ δ → Parser β γ δ

cond

Parser δ γ α → Parser δ γ β → Parser δ γ [α]

endBy, endBy1, sepBy, sepBy1, sepEndBy, sepEndBy1

[(Parser a d b, Parser a d c)] → Parser a d c → Parser a d c

select

Monad α ⇒ α β → α δ → α γ → α γ

between

Parser α β γ → (-> (α β) ((String | γ), α β)→δ ε→((String | ζ), δ ε)) → Parser δ ε ζ

Parser.chg$run

Parser α β γ → (δ ε→((String | ζ), δ ε)) → Parser δ ε ζ

Parser.upd$run