Module Data.NanoParsec

Small parser, inspired by Parsec, but much less versatile

Imports

• import frege.Prelude as Prelude
• import Control.monad.trans.MonadTrans as MonadTrans
• import Control.monad.trans.MonadIO as MonadIO
• import Data.wrapper.Identity as Identity
• import Prelude.PreludeList as PreludeList
• import Prelude.PreludeBase as PreludeBase
• import Prelude.PreludeArrays as PreludeArrays
• import Prelude.PreludeIO as PreludeIO
• import Prelude.PreludeText as PreludeText
• import Prelude.PreludeMonad as PreludeMonad
• import Java.util.Regex as Regexp

Table of Content

• Definitions

  type Parser s t r = ParserT s t Identity r

  data ParserT s t m r

  getPos ∷ Monad β ⇒ ParserT α γ β (α γ)

  putPos ∷ Monad β ⇒ α γ → ParserT α γ β ()

  modifyPos ∷ Monad α ⇒ (γ β→γ β) → ParserT γ β α ()

  failure ∷ Monad α ⇒ String → ParserT δ γ α β

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

  parse ∷ Functor β ⇒ ParserT α γ β δ → α γ → β (String | δ)

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

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

  label ∷ Monad δ ⇒ String → ParserT α γ δ β → ParserT α γ δ β

  <?> ∷ Monad β ⇒ ParserT α γ β δ → String → ParserT α γ β δ 

  expect ∷ (Show β, Monad α, Eq β, ListView γ) ⇒ β → ParserT γ β α β

  eos ∷ (Monad γ, ListView β) ⇒ ParserT β α γ ()

  satisfy ∷ (ListView s, Monad m) ⇒ (t → Bool) → ParserT s t m t

  exceptWhen ∷ (Monad β, ListView α) ⇒ (γ→Bool) → ParserT α γ β ()

  pany ∷ (ListView α, Monad β) ⇒ ParserT α γ β γ

  symbol ∷ (ListView γ, Monad α) ⇒ ParserT γ Char α β → ParserT γ Char α β

  space ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

  digit ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

  letter ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

  uppercase ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

  spaces ∷ (ListView α, Monad β) ⇒ ParserT α Char β ()

  string ∷ Monad m ⇒ String → ParserT StringJ Char m String

  match ∷ Monad α ⇒ Regex → ParserT StringJ Char α Matcher

  optional ∷ Monad m ⇒ ParserT s t m r → ParserT s t m (Maybe r)

  many ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

  some ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

  many1 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

  skip ∷ Monad α ⇒ ParserT β δ α γ → ParserT β δ α ()

  manyWhile ∷ (ListView β, Monad γ) ⇒ (α→Bool) → ParserT β α γ [α]

  skipWhile ∷ (ListView α, Monad β) ⇒ (γ→Bool) → ParserT α γ β ()

  skipUntil ∷ (ListView α, Monad β) ⇒ (γ→Bool) → ParserT α γ β ()

  cond ∷ Bind α ⇒ ParserT γ β α ε → ParserT γ β α δ → ParserT γ β α δ → ParserT γ β α δ

  select ∷ Bind δ ⇒ [(ParserT β α δ γ, ParserT β α δ ε)] → ParserT β α δ ε → ParserT β α δ ε

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

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

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

  option ∷ Monad δ ⇒ β → ParserT α γ δ β → ParserT α γ δ β

  sepBy1 ∷ Monad ε ⇒ ParserT β α ε δ → ParserT β α ε γ → ParserT β α ε [δ]

  sepBy ∷ Monad ε ⇒ ParserT δ α ε β → ParserT δ α ε γ → ParserT δ α ε [β]

  endBy ∷ Monad α ⇒ ParserT γ β α ε → ParserT γ β α δ → ParserT γ β α [ε]

  endBy1 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α ε → ParserT δ β α [γ]

  sepEndBy ∷ Monad β ⇒ ParserT α δ β γ → ParserT α δ β ε → ParserT α δ β [γ]

  sepEndBy1 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α ε → ParserT δ β α [γ]

• Instances

  instance MonadAlt Monad m ⇒ ParserT s t m

  instance MonadIO MonadIO m ⇒ ParserT s t m

  instance MonadTrans ParserT s t

• Functions and Values by Type

Definitions

type Parser s t r = ParserT s t Identity r

Parser Monad

 Parser s t r

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

This does work very much like a combination of State and Either monad, in that the monad bind operations (>>) and (>>=) stop going further if the left hand side signalled an error.

See also ParserT

data ParserT s t m r

Parser Monad Transformer

 ParserT s t m 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 in monad m.

Works in principle like a combination of StateT and EitherT, 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.

ParserT 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 ParserT 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 → m ((String | r), s t)}

Member Functions

run ∷ ParserT δ β α γ → δ β → α ((String | γ), δ β)

access field run

getPos ∷ Monad β ⇒ ParserT α γ β (α γ)

Remember the current state of the input stream.

getPos always succeeds.

putPos ∷ Monad β ⇒ α γ → ParserT α γ β ()

Resume parsing with the given input stream.

putPos always succeeds.

modifyPos ∷ Monad α ⇒ (γ β→γ β) → ParserT γ β α ()

failure ∷ Monad α ⇒ String → ParserT δ γ α β

fail with given error message

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

run a Identity parser

parse ∷ Functor β ⇒ ParserT α γ β δ → α γ → β (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 ∷ Monad δ ⇒ String → ParserT α γ δ β → ParserT α γ δ β

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?

<?> ∷ Monad β ⇒ ParserT α γ β δ → String → ParserT α γ β δ
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 β, Monad α, Eq β, ListView γ) ⇒ β → ParserT γ β α β

 expect t

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

eos ∷ (Monad γ, ListView β) ⇒ ParserT β α γ ()

The eos parser succeeds if the input is empty.

satisfy ∷ (ListView s, Monad m) ⇒ (t → Bool) → ParserT s t m t

 satisfy property

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

exceptWhen ∷ (Monad β, ListView α) ⇒ (γ→Bool) → ParserT α γ β ()

 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 α, Monad β) ⇒ ParserT α γ β γ

 pany

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

symbol ∷ (ListView γ, Monad α) ⇒ ParserT γ Char α β → ParserT γ Char α β

 symbol p

Is the same parser as p, but skips spaces afterwards

space ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

digit ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

letter ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

uppercase ∷ (ListView α, Monad β) ⇒ ParserT α Char β Char

spaces ∷ (ListView α, Monad β) ⇒ ParserT α Char β ()

string ∷ Monad m ⇒ String → ParserT StringJ Char m String

match ∷ Monad α ⇒ Regex → ParserT StringJ Char α Matcher

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

For efficiency reasons, the pattern should start with ^

optional ∷ Monad m ⇒ ParserT s t m r → ParserT s t m (Maybe r)

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

many ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

 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 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

 some p

Like many, except there must be at least one p

Must not be applied to a parser that always succeeds!

many1 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

Alias for some

skip ∷ Monad α ⇒ ParserT β δ α γ → ParserT β δ α ()

 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 β, Monad γ) ⇒ (α→Bool) → ParserT β α γ [α]

 manyWhile p

Collect tokens as long as they satisfy p

skipWhile ∷ (ListView α, Monad β) ⇒ (γ→Bool) → ParserT α γ β ()

 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 α, Monad β) ⇒ (γ→Bool) → ParserT α γ β ()

 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 ∷ Bind α ⇒ ParserT γ β α ε → ParserT γ β α δ → ParserT γ β α δ → ParserT γ β α δ

 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 ∷ Bind δ ⇒ [(ParserT β α δ γ, ParserT β α δ ε)] → ParserT β α δ ε → ParserT β α δ ε

 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 ∷ Monad δ ⇒ β → ParserT α γ δ β → ParserT α γ δ β

 option v p

Applies p, and returns v when it fails.

Always succeeds.

sepBy1 ∷ Monad ε ⇒ ParserT β α ε δ → ParserT β α ε γ → ParserT β α ε [δ]

 p `sepBy1` q

Parses p and many q followed by p

sepBy ∷ Monad ε ⇒ ParserT δ α ε β → ParserT δ α ε γ → ParserT δ α ε [β]

 p `sepBy` q

Like sepBy1, but allows zero p elements

endBy ∷ Monad α ⇒ ParserT γ β α ε → ParserT γ β α δ → ParserT γ β α [ε]

 p `endBy` q

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

endBy1 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α ε → ParserT δ β α [γ]

 p `endBy1` q

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

sepEndBy ∷ Monad β ⇒ ParserT α δ β γ → ParserT α δ β ε → ParserT α δ β [γ]

 p `sepEndBy` q

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

sepEndBy1 ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α ε → ParserT δ β α [γ]

 p `sepEndBy1` q

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

Instances

instance MonadAlt Monad m ⇒ ParserT s t m

Member Functions

*> ∷ Monad δ ⇒ ParserT β α δ γ → ParserT β α δ ε → ParserT β α δ ε
infixl  4

<* ∷ Monad β ⇒ ParserT α δ β γ → ParserT α δ β ε → ParserT α δ β γ
infixl  4

<*> ∷ Monad β ⇒ ParserT α γ β (ε→δ) → ParserT α γ β ε → ParserT α γ β δ
infixl  4

inherited from Monad.<*>

<+> ∷ Monad α ⇒ ParserT δ β α γ → ParserT δ β α γ → ParserT δ β α γ
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

<|> ∷ Monad β ⇒ ParserT α γ β δ → ParserT α γ β δ → ParserT α γ β δ
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'.

>> ∷ Monad β ⇒ ParserT α γ β ε → ParserT α γ β δ → ParserT α γ β δ
infixl  3

inherited from Monad.>>

>>= ∷ Monad α ⇒ ParserT ε β α δ → (δ → ParserT ε β α γ) → ParserT ε β α γ
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 ∷ Monad ε ⇒ (β → α) → ParserT δ γ ε β → ParserT δ γ ε α
infixl  4

inherited from Monad.fmap

join ∷ Monad α ⇒ ParserT γ β α (ParserT γ β α δ) → ParserT γ β α δ

inherited from Monad.join

pure ∷ Monad γ ⇒ β → ParserT δ α γ β

inherited from Monad.pure

pzero ∷ Monad β ⇒ ParserT α γ β δ

generic failure

return ∷ Monad β ⇒ γ → ParserT α δ β γ

generic success

instance MonadIO MonadIO m ⇒ ParserT s t m

Member Functions

liftIO ∷ MonadIO β ⇒ IO γ → ParserT α δ β γ

instance MonadTrans ParserT s t

Member Functions

lift ∷ Monad α ⇒ α β → ParserT δ γ α β

Functions and Values by Type

α → Bool

ParserT.has$run

Monad m ⇒ String → ParserT StringJ Char m String

string

Monad α ⇒ Regex → ParserT StringJ Char α Matcher

match

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

reporterror

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

count

Plus α ⇒ [α β] → α β

choice

(ListView α, Monad β) ⇒ ParserT α Char β ()

spaces

(ListView α, Monad β) ⇒ ParserT α Char β Char

digit, letter, space, uppercase

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

runid

(ListView s, Monad m) ⇒ (t → Bool) → ParserT s t m t

satisfy

(ListView α, Monad β) ⇒ (γ→Bool) → ParserT α γ β ()

skipUntil, skipWhile

(ListView β, Monad γ) ⇒ (α→Bool) → ParserT β α γ [α]

manyWhile

(ListView γ, Monad α) ⇒ ParserT γ Char α β → ParserT γ Char α β

symbol

Monad α ⇒ (γ β→γ β) → ParserT γ β α ()

modifyPos

Monad β ⇒ α γ → ParserT α γ β ()

putPos

(Monad β, ListView α) ⇒ (γ→Bool) → ParserT α γ β ()

exceptWhen

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

parseTest

(Show β, Monad α, Eq β, ListView γ) ⇒ β → ParserT γ β α β

expect

(ListView α, Monad β) ⇒ ParserT α γ β γ

pany

Monad β ⇒ ParserT α γ β (α γ)

getPos

(Monad γ, ListView β) ⇒ ParserT β α γ ()

eos

(s t → m ((String | r), s t)) → ParserT s t m r

ParserT.P

ParserT δ β α γ → δ β → α ((String | γ), δ β)

ParserT.run

MonadIO β ⇒ IO γ → ParserT α δ β γ

MonadIO_ParserT.liftIO

Functor β ⇒ ParserT α γ β δ → α γ → β (String | δ)

parse

Monad m ⇒ ParserT s t m r → ParserT s t m (Maybe r)

optional

Monad α ⇒ ParserT β δ α γ → ParserT β δ α ()

skip

Monad α ⇒ ParserT γ β α (ParserT γ β α δ) → ParserT γ β α δ

MonadAlt_ParserT.join

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

MonadAlt_ParserT.<+>

Monad α ⇒ ParserT δ β α γ → ParserT δ β α [γ]

many, some

Monad α ⇒ String → ParserT δ γ α β

failure

Monad α ⇒ α β → ParserT δ γ α β

MonadTrans_ParserT.lift

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

MonadAlt_ParserT.<|>

Monad β ⇒ ParserT α γ β δ → String → ParserT α γ β δ

<?>

Monad β ⇒ γ → ParserT α δ β γ

MonadAlt_ParserT.return

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

between

Monad γ ⇒ β → ParserT δ α γ β

MonadAlt_ParserT.pure

Monad δ ⇒ String → ParserT α γ δ β → ParserT α γ δ β

label

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

option

Monad β ⇒ ParserT α γ β δ

MonadAlt_ParserT.pzero

Bind α ⇒ ParserT γ β α ε → ParserT γ β α δ → ParserT γ β α δ → ParserT γ β α δ

cond

Bind δ ⇒ [(ParserT β α δ γ, ParserT β α δ ε)] → ParserT β α δ ε → ParserT β α δ ε

select

Monad α ⇒ ParserT γ β α ε → ParserT γ β α δ → ParserT γ β α [ε]

endBy

Monad α ⇒ ParserT δ β α γ → ParserT δ β α ε → ParserT δ β α [γ]

endBy1, sepEndBy1

Monad α ⇒ ParserT ε β α δ → (δ → ParserT ε β α γ) → ParserT ε β α γ

MonadAlt_ParserT.>>=

Monad β ⇒ ParserT α γ β (ε→δ) → ParserT α γ β ε → ParserT α γ β δ

MonadAlt_ParserT.<*>

Monad β ⇒ ParserT α γ β ε → ParserT α γ β δ → ParserT α γ β δ

MonadAlt_ParserT.>>

Monad β ⇒ ParserT α δ β γ → ParserT α δ β ε → ParserT α δ β [γ]

sepEndBy

Monad β ⇒ ParserT α δ β γ → ParserT α δ β ε → ParserT α δ β γ

MonadAlt_ParserT.<*

Monad δ ⇒ ParserT β α δ γ → ParserT β α δ ε → ParserT β α δ ε

MonadAlt_ParserT.*>

Monad ε ⇒ (β → α) → ParserT δ γ ε β → ParserT δ γ ε α

MonadAlt_ParserT.fmap

Monad ε ⇒ ParserT β α ε δ → ParserT β α ε γ → ParserT β α ε [δ]

sepBy1

Monad ε ⇒ ParserT δ α ε β → ParserT δ α ε γ → ParserT δ α ε [β]

sepBy

ParserT β δ γ α → (ε ζ→η ((String | θ), ε ζ)) → ParserT ε ζ η θ

ParserT.upd$run

ParserT θ α ε ζ → (-> (θ α) (ε ((String | ζ), θ α))→η δ→β ((String | γ), η δ)) → ParserT η δ β γ

ParserT.chg$run