OnceParser

trait OnceParser[+T] extends Parser[T]

A parser whose ~ combinator disallows back-tracking.

1. Parser
2. Function1
3. AnyRef
4. Any

Value Members

1. def *[U >: T](sep: ⇒ Parser[(U, U) ⇒ U]): 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.

definition classes: Parser
2. def *: Parser[List[T]]

Returns a parser that repeatedly parses what this parser parses

Returns a parser that repeatedly parses what this parser parses

definition classes: Parser
3. def +: 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.

definition classes: Parser
4. def <~[U](p: ⇒ Parser[U]): 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'.

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

definition classes: Parser
5. def >>[U](fq: (T) ⇒ Parser[U]): Parser[U]

Returns into(fq)

Returns into(fq)

definition classes: Parser
6. def ?: Parser[Option[T]]

Returns a parser that optionally parses what this parser parses

Returns a parser that optionally parses what this parser parses.

definition classes: Parser
7. def ^?[U](f: PartialFunction[T, U]): 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
8. def ^?[U](f: PartialFunction[T, U], error: (T) ⇒ String): 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
9. def ^^[U](f: (T) ⇒ U): 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

11. def andThen[A](g: (ParseResult[T]) ⇒ A): (Reader[Elem]) ⇒ A

(f andThen g)(x) == g(f(x))

(f andThen g)(x) == g(f(x))

definition classes: Function1
12. def append[U >: T](p: ⇒ Parser[U]): Parser[U]

An unspecified method that defines the behaviour of this parser

An unspecified method that defines the behaviour of this parser.

attributes: abstract
definition classes: ParserFunction1
14. def compose[A](g: (A) ⇒ Reader[Elem]): (A) ⇒ ParseResult[T]

(f compose g)(x) == f(g(x))

(f compose g)(x) == f(g(x))

definition classes: Function1
15. def equals(arg0: Any): Boolean

This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence

This method is used to compare the receiver object (`this`) with the argument object (`arg0`) for equivalence.

The default implementations of this method is an equivalence relation:

• It is reflexive: for any instance `x` of type `Any`, `x.equals(x)` should return `true`.
• It is symmetric: for any instances `x` and `y` of type `Any`, `x.equals(y)` should return `true` if and only if `y.equals(x)` returns `true`.
• It is transitive: for any instances `x`, `y`, and `z` of type `AnyRef` if `x.equals(y)` returns `true` and `y.equals(z)` returns `true`, then `x.equals(z)` should return `true`.

If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override `hashCode` to ensure that objects that are "equal" (`o1.equals(o2)` returns `true`) hash to the same `Int` (`o1.hashCode.equals(o2.hashCode)`).

arg0

the object to compare against this object for equality.

returns

`true` if the receiver object is equivalent to the argument; `false` otherwise.

definition classes: AnyRef ⇐ Any

17. def hashCode(): Int

Returns a hash code value for the object

Returns a hash code value for the object.

The default hashing algorithm is platform dependent.

Note that it is allowed for two objects to have identical hash codes (`o1.hashCode.equals(o2.hashCode)`) yet not be equal (`o1.equals(o2)` returns `false`). A degenerate implementation could always return `0`. However, it is required that if two objects are equal (`o1.equals(o2)` returns `true`) that they have identical hash codes (`o1.hashCode.equals(o2.hashCode)`). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the `equals` method.

definition classes: AnyRef ⇐ Any
18. def into[U](fq: (T) ⇒ Parser[U]): Parser[U]

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

A parser combinator that parameterises 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

21. def toString(): String

Returns a string representation of the object

Returns a string representation of the object.

The default representation is platform dependent.

definition classes: ParserFunction1 ⇐ AnyRef ⇐ Any
22. def |[U >: T](q: ⇒ Parser[U]): 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 ```p's 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
23. def |||[U >: T](q: ⇒ Parser[U]): 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.```

``` ```

q

a parser that accepts if p consumes less characters.

returns

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

definition classes: Parser
24. def ~[U](p: ⇒ Parser[U]): Parser[~[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'.

25. def ~![U](p: ⇒ Parser[U]): Parser[~[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).

definition classes: Parser
26. def ~>[U](p: ⇒ Parser[U]): 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'.

definition classes: Parser