molecule.parsers.charbuffer.RegexParsers

Type Members

class LitteralParser extends Parser[CharBuffer, String]
class RegexParser extends Parser[CharBuffer, String]

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def accept[U](expected: CharBuffer, f: PartialFunction[CharBuffer, U]): Parser[CharBuffer, U]

The parser that matches an element in the domain of the partial function f'
The parser that matches an element in the domain of the partial function f'
If f' is defined on the first element in the input, f' is applied to it to produce this parser's result.
Example: The parser accept("name", {case Identifier(n) => Name(n)}) accepts an Identifier(n) and returns a Name(n).
expected
a description of the kind of element this parser expects (for error messages)
f
a partial function that determines when this parser is successful and what its output is
returns
A parser that succeeds if f' is applicable to the first element of the input, applyingf' to it to produce the result.

Definition Classes
Parsers
def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[CharBuffer]): Parser[CharBuffer, Seg[CharBuffer]]

A parser that matches only the given list of element es'
A parser that matches only the given list of element es'
accept(es) succeeds if the input subsequently provides the elements in the list es'.
es
the list of expected elements
returns
a Parser that recognizes a specified list of elements

Definition Classes
Parsers
implicit def accept(e: CharBuffer): Parser[CharBuffer, CharBuffer]

A parser that matches only the given element e'
A parser that matches only the given element e'
The method is implicit so that elements can automatically be lifted to their parsers. For example, when parsing Token's, Identifier("new") (which is a Token') can be used directly, instead of first creating a Parser' using accept(Identifier("new")).
e
the Elem' that must be the next piece of input for the returned parser to succeed
returns
a tParser' that succeeds if e' is the next available input.

Definition Classes
Parsers
def acceptAny: Parser[CharBuffer, CharBuffer]

Definition Classes
Parsers
def acceptIf(p: (CharBuffer) ⇒ Boolean)(err: (CharBuffer) ⇒ String): Parser[CharBuffer, CharBuffer]

Definition Classes
Parsers
def acceptMatch[U](expected: CharBuffer, f: PartialFunction[CharBuffer, U]): Parser[CharBuffer, U]

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[CharBuffer]): Parser[CharBuffer, Seg[CharBuffer]]

Definition Classes
Parsers
def acceptSignal(signal: Signal): Parser[CharBuffer, Nothing]

Definition Classes
Parsers
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def elem(e: CharBuffer): Parser[CharBuffer, CharBuffer]

A parser that matches only the given element e'
A parser that matches only the given element e'
The method is implicit so that elements can automatically be lifted to their parsers. For example, when parsing Token's, Identifier("new") (which is a Token') can be used directly, instead of first creating a Parser' using accept(Identifier("new")).
e
the Elem' that must be the next piece of input for the returned parser to succeed
returns
a Parser' that succeeds if e' is the next available input.

Definition Classes
Parsers
def elem(kind: String, p: (CharBuffer) ⇒ Boolean): Parser[CharBuffer, CharBuffer]

A parser matching input elements that satisfy a given predicate
A parser matching input elements that satisfy a given predicate
elem(kind, p) succeeds if the input starts with an element e' for which p(e) is true.
kind
The element kind, used for error messages
p
A predicate that determines which elements match. @return

Definition Classes
Parsers
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail(msg: ⇒ String): Parser[CharBuffer, Nothing]

A parser that results in a parse failure
A parser that results in a parse failure
msg
The error message describing the failure.
returns
A parser to Nothing that always generates a Fail result.

Definition Classes
Parsers
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
final def getClass(): java.lang.Class[_]

Definition Classes
AnyRef → Any
def handleWhiteSpace(source: Seg[CharBuffer]): Seg[CharBuffer]

Attributes
protected
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def literal(s: String): Parser[CharBuffer, String]

A parser that matches a literal string
def log[T](p: ⇒ Parser[CharBuffer, T])(name: String): Parser[CharBuffer, T]

Log interactions with this parser
Log interactions with this parser

Definition Classes
Parsers
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
def mkSeg[T]: (~[T, Seg[T]]) ⇒ Seg[T]

Definition Classes
Parsers
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def opt[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Option[T]]

A parser generator for optional sub-phrases.
A parser generator for optional sub-phrases.
opt(p) is a parser that returns Some(x)' if p' returns x' and None' if p' fails
p
A Parser' that is tried on the input
returns
a Parser' that always succeeds: either with the result provided by p' or with the empty result

Definition Classes
Parsers
implicit def parsers: Parsers[CharBuffer]

Definition Classes
Parsers
implicit def regex(r: Regex): Parser[CharBuffer, String]

A parser that matches a regex string
def rep[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

A parser generator for repetitions.
A parser generator for repetitions.
rep(p) repeatedly uses p' to parse the input until p' fails (the result is a List of the consecutive results of p')
p
a Parser' that is to be applied successively to the input
returns
A parser that returns a list of results produced by repeatedly applying p' to the input.

Definition Classes
Parsers
def rep1[T](first: ⇒ Parser[CharBuffer, T], next: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1(f, p) first uses f' (which must succeed) and then repeatedly uses p' to parse the input until p' fails (the result is aList' of the consecutive results of f' and p')
first
a Parser' that parses the first piece of input
next
a Parser' that is to be applied successively to the rest of the input (if any)
returns
A parser that returns a list of results produced by first applying f' and then repeatedlyp' to the input (it only succeeds if f' matches).

Definition Classes
Parsers
def rep1[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1(p) repeatedly uses p' to parse the input until p' fails -- p' must succeed at least once (the result is aList' of the consecutive results of p')
p
a Parser' that is to be applied successively to the input
returns
A parser that returns a list of results produced by repeatedly applying p' to the input (and that only succeeds ifp' matches at least once).

Definition Classes
Parsers
def rep1sep[T](p: ⇒ Parser[CharBuffer, T], q: ⇒ Parser[CharBuffer, Any]): Parser[CharBuffer, Seg[T]]

A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1sep(p, q) repeatedly applies p' interleaved with q' to parse the input, until p' fails. The parserp' must succeed at least once.
p
a Parser' that is to be applied successively to the input
q
a Parser' that parses the elements that separate the elements parsed by p' (interleaved with q')
returns
A parser that returns a list of results produced by repeatedly applying p' to the input (and that only succeeds ifp' matches at least once). The results of p' are collected in a list. The results of q' are discarded.

Definition Classes
Parsers
def repN[T](num: Int, p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

A parser generator for a specified number of repetitions.
A parser generator for a specified number of repetitions.
repN(n, p) uses p' exactly n' time to parse the input (the result is a List' of the n' consecutive results of p')
p
a Parser' that is to be applied successively to the input
returns
A parser that returns a list of results produced by repeatedly applying p' to the input (and that only succeeds ifp' matches exactly n' times).

Definition Classes
Parsers
def repsep[T](p: ⇒ Parser[CharBuffer, T], q: ⇒ Parser[CharBuffer, Any]): Parser[CharBuffer, Seg[T]]

A parser generator for interleaved repetitions.
A parser generator for interleaved repetitions.
repsep(p, q) repeatedly uses p' interleaved with q' to parse the input, until p' fails. (The result is aList' of the results of p'.)
Example: repsep(term, ",") parses a comma-separated list of term's, yielding a list of these terms
p
a Parser' that is to be applied successively to the input
q
a Parser' that parses the elements that separate the elements parsed by p'
returns
A parser that returns a list of results produced by repeatedly applying p' (interleaved withq') to the input. The results of p' are collected in a list. The results of q' are discarded.

Definition Classes
Parsers
def skipWhitespace: Boolean
def success[T](v: T): Parser[CharBuffer, T] { ... /* 2 definitions in type refinement */ }

A parser that always succeeds
A parser that always succeeds
v
The result for the parser
returns
A parser that always succeeds, with the given result v'

Definition Classes
Parsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
val whiteSpace: Regex

Attributes
protected

Deprecated Value Members

def err(msg: ⇒ String): Parser[CharBuffer, CharBuffer]

A parser that results in an error
A parser that results in an error
msg
The error message describing the failure.
returns
A parser that always fails with the specified error message.

Definition Classes
Parsers
Annotations
@deprecated
Deprecated
(Since version r95) Use fail(msg: => String): Parser[ByteBuffer, Nothing] in stead. Not to be confused with scala.Predef.error(msg:String):Nothing or sys.error(msg:String):Nothing, which will generate a runtime error

RegexParsers

trait RegexParsers extends Parsers[CharBuffer]

Type Members

class LitteralParser extends Parser[CharBuffer, String]

class RegexParser extends Parser[CharBuffer, String]

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def accept[U](expected: CharBuffer, f: PartialFunction[CharBuffer, U]): Parser[CharBuffer, U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[CharBuffer]): Parser[CharBuffer, Seg[CharBuffer]]

implicit def accept(e: CharBuffer): Parser[CharBuffer, CharBuffer]

def acceptAny: Parser[CharBuffer, CharBuffer]

def acceptIf(p: (CharBuffer) ⇒ Boolean)(err: (CharBuffer) ⇒ String): Parser[CharBuffer, CharBuffer]

def acceptMatch[U](expected: CharBuffer, f: PartialFunction[CharBuffer, U]): Parser[CharBuffer, U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[CharBuffer]): Parser[CharBuffer, Seg[CharBuffer]]

def acceptSignal(signal: Signal): Parser[CharBuffer, Nothing]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def elem(e: CharBuffer): Parser[CharBuffer, CharBuffer]

def elem(kind: String, p: (CharBuffer) ⇒ Boolean): Parser[CharBuffer, CharBuffer]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail(msg: ⇒ String): Parser[CharBuffer, Nothing]

def finalize(): Unit

final def getClass(): java.lang.Class[_]

def handleWhiteSpace(source: Seg[CharBuffer]): Seg[CharBuffer]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def literal(s: String): Parser[CharBuffer, String]

def log[T](p: ⇒ Parser[CharBuffer, T])(name: String): Parser[CharBuffer, T]

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

def mkSeg[T]: (~[T, Seg[T]]) ⇒ Seg[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Option[T]]

implicit def parsers: Parsers[CharBuffer]

implicit def regex(r: Regex): Parser[CharBuffer, String]

def rep[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def rep1[T](first: ⇒ Parser[CharBuffer, T], next: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def rep1[T](p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def rep1sep[T](p: ⇒ Parser[CharBuffer, T], q: ⇒ Parser[CharBuffer, Any]): Parser[CharBuffer, Seg[T]]

def repN[T](num: Int, p: ⇒ Parser[CharBuffer, T]): Parser[CharBuffer, Seg[T]]

def repsep[T](p: ⇒ Parser[CharBuffer, T], q: ⇒ Parser[CharBuffer, Any]): Parser[CharBuffer, Seg[T]]

def skipWhitespace: Boolean

def success[T](v: T): Parser[CharBuffer, T] { ... /* 2 definitions in type refinement */ }

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val whiteSpace: Regex

Deprecated Value Members

def err(msg: ⇒ String): Parser[CharBuffer, CharBuffer]

Inherited from Parsers[CharBuffer]

Inherited from AnyRef

Inherited from Any