Little.Earley.Internal.Result

Documentation

data Result n t c

Result of parse.

Constructors

ParseError (Error t c)

ParseSuccess (ParsedResult n t c)

Instances

(PrettyPrint n, PrettyPrint t, PrettyPrint c) => PrettyPrint (Result n t c)

Defined in Little.Earley.Internal.Result

Methods

prettyPrint :: Result n t c -> String

data ParsedResult n t c

Successful result of parse.

Constructors

ParsedResult

Fields

• prParseTree :: TreeSet n t c

  The resulting parse tree.

• prAmbiguities :: [LocAmbiguity n t c]

  A stream of localized ambiguities, when the parse tree is ambiguous.

data Error t c

Parser error information.

Constructors

Error

Fields

• errorPosition :: Int
• errorToken :: Maybe c

  Nothing if end of input

• errorExpected :: [t]
• errorInput :: [c]

diagnoseError :: Ord t => Seq1 (Set (Item n t)) -> [c] -> Error t c

lastNot :: (a -> Bool) -> Seq1 a -> (Int, a)

nub_ :: Ord a => [a] -> [a]

parse :: (Ord n, Ord t) => Grammar n t c -> n -> [c] -> Result n t c

Parse a chain of tokens [c] given a grammar and a starting symbol n.

Variants:

• pparse: pretty-printed; use this in the REPL.
• parseTreeSet: outputs just the parse tree.
• accepts: outputs a mere boolean.

Example

parse arithG SUM "1+2*3"

pparse :: (Ord n, Ord t) => Grammar n t c -> n -> [c] -> Pretty (Result n t c)

Wrapped parse with a pretty-printed result. Use this in the REPL.

Example

pparse arithG SUM "1+2*3"

Output:

     +-----+--SUM #1---+
     |     |           |
  SUM #0   |      +PRODUCT #1-+
     |     |      |     |     |
PRODUCT #0 | PRODUCT #0 |     |
     |     |      |     |     |
 FACTOR #0 |  FACTOR #0 | FACTOR #0
     |     |      |     |     |
 NUMBER #0 |  NUMBER #0 | NUMBER #0
     |     |      |     |     |
-----------------------------------
     1     +      2     *     3