Packages

  • package root
    Definition Classes
    root
  • package scala
    Definition Classes
    root
  • package util
    Definition Classes
    scala
  • package parsing
    Definition Classes
    util
  • package combinator
    Definition Classes
    parsing
  • trait PackratParsers extends Parsers

    PackratParsers is a component that extends the parser combinators provided by scala.util.parsing.combinator.Parsers with a memoization facility (Packrat Parsing).

    PackratParsers is a component that extends the parser combinators provided by scala.util.parsing.combinator.Parsers with a memoization facility (Packrat Parsing).

    Packrat Parsing is a technique for implementing backtracking, recursive-descent parsers, with the advantage that it guarantees unlimited lookahead and a linear parse time. Using this technique, left recursive grammars can also be accepted.

    Using PackratParsers is very similar to using Parsers:

    • any class/trait that extends Parsers (directly or through a subclass) can mix in PackratParsers. Example: object MyGrammar extends StandardTokenParsers with PackratParsers
    • each grammar production previously declared as a def without formal parameters becomes a lazy val, and its type is changed from Parser[Elem] to PackratParser[Elem]. So, for example, def production: Parser[Int] = {...} becomes lazy val production: PackratParser[Int] = {...}
    • Important: using PackratParsers is not an all or nothing decision. They can be free mixed with regular Parsers in a single grammar.

    Cached parse results are attached to the input, not the grammar. Therefore, PackratsParsers require a PackratReader as input, which adds memoization to an underlying Reader. Programmers can create PackratReader objects either manually, as in production(new PackratReader(new lexical.Scanner("input"))), but the common way should be to rely on the combinator phrase to wrap a given input with a PackratReader if the input is not one itself.

    Definition Classes
    combinator
    Since

    2.8

    See also

    Alessandro Warth, James R. Douglass, Todd Millstein: "Packrat Parsers Can Support Left Recursion." PEPM'08

    Bryan Ford: "Packrat Parsing: Simple, Powerful, Lazy, Linear Time." ICFP'02

  • Elem
  • Error
  • Failure
  • NoSuccess
  • OnceParser
  • PackratParser
  • PackratReader
  • ParseResult
  • Parser
  • Success
  • ~

abstract class PackratParser[+T] extends Parser[T]

The root class of packrat parsers.

Source
PackratParsers.scala
Linear Supertypes
PackratParsers.Parser[T], (PackratParsers.Input) ⇒ PackratParsers.ParseResult[T], AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. PackratParser
  2. Parser
  3. Function1
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new PackratParser()

Abstract Value Members

  1. abstract def apply(in: PackratParsers.Input): PackratParsers.ParseResult[T]

    An unspecified method that defines the behaviour of this parser.

    An unspecified method that defines the behaviour of this parser.

    Definition Classes
    Parser → Function1

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. def *[U >: T](sep: ⇒ PackratParsers.Parser[(U, U) ⇒ U]): PackratParsers.Parser[U]

    Returns a parser that repeatedly parses what this parser parses, interleaved with the sep parser.

    Returns a parser that repeatedly parses what this parser parses, interleaved with the sep parser. The sep parser specifies how the results parsed by this parser should be combined.

    returns

    chainl1(this, sep)

    Definition Classes
    Parser
  4. def *: PackratParsers.Parser[List[T]]

    Returns a parser that repeatedly parses what this parser parses.

    Returns a parser that repeatedly parses what this parser parses.

    returns

    rep(this)

    Definition Classes
    Parser
  5. def +: PackratParsers.Parser[List[T]]

    Returns a parser that repeatedly (at least once) parses what this parser parses.

    Returns a parser that repeatedly (at least once) parses what this parser parses.

    returns

    rep1(this)

    Definition Classes
    Parser
  6. def <~[U](q: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[T]

    A parser combinator for sequential composition which keeps only the left result.

    A parser combinator for sequential composition which keeps only the left result.

    p <~ q succeeds if p succeeds and q succeeds on the input left over by p.

    q

    a parser that will be executed after p (this parser) succeeds -- evaluated at most once, and only when necessary

    returns

    a Parser that -- on success -- returns the result of p.

    Definition Classes
    Parser
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

    Note

    <~ has lower operator precedence than ~ or ~>.

  7. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  8. def >>[U](fq: (T) ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]

    Returns into(fq).

    Returns into(fq).

    Definition Classes
    Parser
  9. def ?: PackratParsers.Parser[Option[T]]

    Returns a parser that optionally parses what this parser parses.

    Returns a parser that optionally parses what this parser parses.

    returns

    opt(this)

    Definition Classes
    Parser
  10. def ^?[U](f: PartialFunction[T, U]): PackratParsers.Parser[U]

    A parser combinator for partial function application.

    A parser combinator for partial function application.

    p ^? f succeeds if p succeeds AND f is defined at the result of p; in that case, it returns f applied to the result of p.

    f

    a partial function that will be applied to this parser's result (see mapPartial in ParseResult).

    returns

    a parser that succeeds if the current parser succeeds and f is applicable to the result. If so, the result will be transformed by f.

    Definition Classes
    Parser
  11. def ^?[U](f: PartialFunction[T, U], error: (T) ⇒ String): PackratParsers.Parser[U]

    A parser combinator for partial function application.

    A parser combinator for partial function application.

    p ^? (f, error) succeeds if p succeeds AND f is defined at the result of p; in that case, it returns f applied to the result of p. If f is not applicable, error(the result of p) should explain why.

    f

    a partial function that will be applied to this parser's result (see mapPartial in ParseResult).

    error

    a function that takes the same argument as f and produces an error message to explain why f wasn't applicable

    returns

    a parser that succeeds if the current parser succeeds and f is applicable to the result. If so, the result will be transformed by f.

    Definition Classes
    Parser
  12. def ^^[U](f: (T) ⇒ U): PackratParsers.Parser[U]

    A parser combinator for function application.

    A parser combinator for function application.

    p ^^ f succeeds if p succeeds; it returns f applied to the result of p.

    f

    a function that will be applied to this parser's result (see map in ParseResult).

    returns

    a parser that has the same behaviour as the current parser, but whose result is transformed by f.

    Definition Classes
    Parser
  13. def ^^^[U](v: ⇒ U): PackratParsers.Parser[U]

    A parser combinator that changes a successful result into the specified value.

    A parser combinator that changes a successful result into the specified value.

    p ^^^ v succeeds if p succeeds; discards its result, and returns v instead.

    v

    The new result for the parser, evaluated at most once (if p succeeds), not evaluated at all if p fails.

    returns

    a parser that has the same behaviour as the current parser, but whose successful result is v

    Definition Classes
    Parser
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

  14. def andThen[A](g: (PackratParsers.ParseResult[T]) ⇒ A): (PackratParsers.Input) ⇒ A
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  15. def append[U >: T](p0: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]
    Definition Classes
    Parser
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

  16. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  17. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  18. def compose[A](g: (A) ⇒ PackratParsers.Input): (A) ⇒ PackratParsers.ParseResult[T]
    Definition Classes
    Function1
    Annotations
    @unspecialized()
  19. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  20. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  21. def filter(p: (T) ⇒ Boolean): PackratParsers.Parser[T]
    Definition Classes
    Parser
  22. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  23. def flatMap[U](f: (T) ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]
    Definition Classes
    Parser
  24. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  25. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  26. def into[U](fq: (T) ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]

    A parser combinator that parameterizes a subsequent parser with the result of this one.

    A parser combinator that parameterizes a subsequent parser with the result of this one.

    Use this combinator when a parser depends on the result of a previous parser. p should be a function that takes the result from the first parser and returns the second parser.

    p into fq (with fq typically {x => q}) first applies p, and then, if p successfully returned result r, applies fq(r) to the rest of the input.

    From: G. Hutton. Higher-order functions for parsing. J. Funct. Program., 2(3):323--343, 1992.

    fq

    a function that, given the result from this parser, returns the second parser to be applied

    returns

    a parser that succeeds if this parser succeeds (with result x) and if then fq(x) succeeds

    Definition Classes
    Parser
    Example: 

    1. def perlRE = "m" ~> (".".r into (separator => """[^%s]*""".format(separator).r <~ separator))
  27. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  28. def map[U](f: (T) ⇒ U): PackratParsers.Parser[U]
    Definition Classes
    Parser
  29. def named(n: String): PackratParser.this.type
    Definition Classes
    Parser
  30. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  31. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  32. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  33. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  34. def toString(): String
    Definition Classes
    Parser → Function1 → AnyRef → Any
  35. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  36. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  37. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  38. def withErrorMessage(msg: String): PackratParsers.Parser[T]

    Changes the error message produced by a parser.

    Changes the error message produced by a parser.

    This doesn't change the behavior of a parser on neither success nor failure, just on error. The semantics are slightly different than those obtained by doing | error(msg), in that the message produced by this method will always replace the message produced, which is not guaranteed by that idiom.

    For example, parser p below will always produce the designated error message, while q will not produce it if sign is parsed but number is not.

    def p = sign.? ~ number withErrorMessage  "Number expected!"
def q = sign.? ~ number | error("Number expected!")
    msg

    The message that will replace the default error message.

    returns

    A parser with the same properties and different error message.

    Definition Classes
    Parser
  39. def withFailureMessage(msg: String): PackratParsers.Parser[T]

    Changes the failure message produced by a parser.

    Changes the failure message produced by a parser.

    This doesn't change the behavior of a parser on neither success nor error, just on failure. The semantics are slightly different than those obtained by doing | failure(msg), in that the message produced by this method will always replace the message produced, which is not guaranteed by that idiom.

    For example, parser p below will always produce the designated failure message, while q will not produce it if sign is parsed but number is not.

    def p = sign.? ~ number withFailureMessage  "Number expected!"
def q = sign.? ~ number | failure("Number expected!")
    msg

    The message that will replace the default failure message.

    returns

    A parser with the same properties and different failure message.

    Definition Classes
    Parser
  40. def withFilter(p: (T) ⇒ Boolean): PackratParsers.Parser[T]
    Definition Classes
    Parser
  41. def |[U >: T](q: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]

    A parser combinator for alternative composition.

    A parser combinator for alternative composition.

    p | q succeeds if p succeeds or q succeeds. Note that q is only tried if ps failure is non-fatal (i.e., back-tracking is allowed).

    q

    a parser that will be executed if p (this parser) fails (and allows back-tracking)

    returns

    a Parser that returns the result of the first parser to succeed (out of p and q) The resulting parser succeeds if (and only if)

    • p succeeds, or
    • if p fails allowing back-tracking and q succeeds.
    Definition Classes
    Parser
  42. def |||[U >: T](q0: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]

    A parser combinator for alternative with longest match composition.

    A parser combinator for alternative with longest match composition.

    p ||| q succeeds if p succeeds or q succeeds. If p and q both succeed, the parser that consumed the most characters accepts.

    q0

    a parser that accepts if p consumes less characters. -- evaluated at most once, and only when necessary

    returns

    a Parser that returns the result of the parser consuming the most characters (out of p and q).

    Definition Classes
    Parser
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

  43. def ~[U](q: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[PackratParsers.~[T, U]]

    A parser combinator for sequential composition.

    A parser combinator for sequential composition.

    p ~ q succeeds if p succeeds and q succeeds on the input left over by p.

    q

    a parser that will be executed after p (this parser) succeeds -- evaluated at most once, and only when necessary.

    returns

    a Parser that -- on success -- returns a ~ (like a Pair, but easier to pattern match on) that contains the result of p and that of q. The resulting parser fails if either p or q fails.

    Definition Classes
    Parser
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

  44. def ~![U](p: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[PackratParsers.~[T, U]]

    A parser combinator for non-back-tracking sequential composition.

    A parser combinator for non-back-tracking sequential composition.

    p ~! q succeeds if p succeeds and q succeeds on the input left over by p. In case of failure, no back-tracking is performed (in an earlier parser produced by the | combinator).

    p

    a parser that will be executed after p (this parser) succeeds

    returns

    a Parser that -- on success -- returns a ~ (like a Pair, but easier to pattern match on) that contains the result of p and that of q. The resulting parser fails if either p or q fails, this failure is fatal.

    Definition Classes
    Parser
  45. def ~>[U](q: ⇒ PackratParsers.Parser[U]): PackratParsers.Parser[U]

    A parser combinator for sequential composition which keeps only the right result.

    A parser combinator for sequential composition which keeps only the right result.

    p ~> q succeeds if p succeeds and q succeeds on the input left over by p.

    q

    a parser that will be executed after p (this parser) succeeds -- evaluated at most once, and only when necessary.

    returns

    a Parser that -- on success -- returns the result of q.

    Definition Classes
    Parser
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The call-by-name argument is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

Inherited from PackratParsers.Parser[T]

Inherited from (PackratParsers.Input) ⇒ PackratParsers.ParseResult[T]

Inherited from AnyRef

Inherited from Any

Ungrouped