DefaultParsers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

lazy val BackslashChar: Char

Backslash character.

lazy val Bool: Parser[Boolean]

Parses the lower-case values true and false into their respesct Boolean values.

lazy val DQuoteChar: Char

Double quote character.

lazy val DQuoteClass: Parser[Char]

Matches a single double quote.

lazy val Digit: Parser[Char]

Parses any single digit and provides that digit as a Char as the result.

lazy val DigitSet: Set[String]

Set that contains each digit in a String representation.

lazy val EOF: Parser[Unit]

Matches the end of input, providing no useful result on success.

lazy val EscapeSequence: Parser[Char]

Parses a single escape sequence into the represented Char.

lazy val HexDigit: Parser[Char]

Parses a single hexadecimal digit (0-9, a-f, A-F).

lazy val HexDigitSet: Set[Char]

Set containing Chars for hexadecimal digits 0-9 and A-F (but not a-f).

lazy val ID: Parser[String]

Parses an identifier String, which must start with IDStart and contain zero or more IDChars after that.

lazy val IDChar: Parser[Char]

Parses an identifier Char other than the first character.

def IDStart: Parser[Char]

Parses the first Char in an sbt identifier, which must be a Letter.

lazy val IntBasic: Parser[Int]

Parses a signed integer.

lazy val Letter: Parser[Char]

Parses a single letter, according to Char.

lazy val NatBasic: Parser[Int]

Parses an unsigned integer.

lazy val NotDQuoteBackslashClass: Parser[Char]

Matches any character except a double quote or backslash.

lazy val NotDQuoteSpaceClass: Parser[Char]

Matches any character except a double quote or whitespace.

lazy val NotQuoted: Parser[String]

Parses an unquoted, non-empty String value that cannot start with a double quote and cannot contain whitespace.

lazy val NotSpace: Parser[String]

Matches a non-empty String consisting of non-whitespace characters.

lazy val NotSpaceClass: Parser[Char]

Matches a single character that is not a whitespace character.

lazy val Op: Parser[String]

Parses a non-empty operator String, which consists only of characters allowed by OpChar.

lazy val OpChar: Parser[Char]

Parses a single operator Char, as allowed by isOpChar.

lazy val OpOrID: Parser[String]

Parses either an operator String defined by Op or a non-symbolic identifier defined by ID.

lazy val OptNotSpace: Parser[String]

Matches a possibly empty String consisting of non-whitespace characters.

lazy val OptSpace: Parser[Seq[Char]]

Matches a possibly empty String consisting of whitespace characters.

lazy val Port: Parser[Int]

Parses a port number.

lazy val ScalaID: Parser[String]

Parses a non-symbolic Scala-like identifier.

lazy val ScalaIDChar: Parser[Char]

Parses a single, non-symbolic Scala identifier Char.

lazy val Space: Parser[Seq[Char]]

Matches a non-empty String consisting of whitespace characters.

lazy val SpaceClass: Parser[Char]

Matches a single whitespace character, as determined by Char.

lazy val StringBasic: Parser[String]

Parses a potentially quoted String value.

lazy val StringEscapable: Parser[String]

Parses a string value, interpreting escapes and discarding the surrounding quotes in the result.

lazy val StringVerbatim: Parser[String]

Parses a verbatim quoted String value, discarding the quotes in the result.

lazy val URIChar: Parser[Char]

Matches a single character that is valid somewhere in a URI.

lazy val URIClass: Parser[String]

Parses a non-empty String that contains only valid URI characters, as defined by URIChar.

lazy val UnicodeEscape: Parser[Char]

Parses a single unicode escape sequence into the represented Char.

def Uri(ex: Set[URI]): Parser[URI]

Parses a URI that is valid according to the single argument java.

lazy val VerbatimDQuotes: String

Triple-quotes, as used for verbatim quoting.

def alphanum(c: Char): Boolean

Returns true if c is an ASCII letter or digit.

lazy val any: Parser[Char]

Parses any single character and provides that character as the result.

def apply[T](p: Parser[T])(s: String): Parser[T]

Applies parser p to input s.

final def asInstanceOf[T0]: T0

lazy val basicUri: Parser[URI]

Parses a URI that is valid according to the single argument java.

def charClass(f: (Char) ⇒ Boolean, label: String = "<unspecified>"): Parser[Char]

Defines a Parser that parses a single character only if the predicate f returns true for that character.

def chars(legal: String): Parser[Char]

Defines a Parser that parses a single character only if it is contained in legal.

def clone(): AnyRef

def completions(p: Parser[_], s: String, level: Int): Completions

Applies parser p to input s and returns the completions at verbosity level.

def derive1[T](p: Parser[T], c: Char): Parser[T]

Applies parser p to a single character of input.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def examples[A](a: Parser[A], completions: ExampleSource, maxNumberOfExamples: Int, removeInvalidExamples: Boolean): Parser[A]

def examples[A](a: Parser[A], completions: Set[String], check: Boolean = false): Parser[A]

def failure(msg: ⇒ String, definitive: Boolean = false): Parser[Nothing]

Defines a parser that always fails on any input with message msg.

def fileParser(base: File): Parser[File]

def finalize(): Unit

def flag[T](p: Parser[T]): Parser[Boolean]

Applies p and uses true as the result if it succeeds and turns failure into a result of false.

final def getClass(): Class[_]

def hashCode(): Int

def homParser[A](a: Parser[A], b: Parser[A]): Parser[A]

def identifier(start: Parser[Char], rep: Parser[Char]): Parser[String]

Parses a String that starts with start and is followed by zero or more characters parsed by rep.

def invalid(msgs: ⇒ Seq[String], definitive: Boolean = false): Parser[Nothing]

Defines a parser that always fails on any input with messages msgs.

def isDelimiter(c: Char): Boolean

def isIDChar(c: Char): Boolean

Returns true if c is a dash -, a letter, digit, or an underscore _.

final def isInstanceOf[T0]: Boolean

def isOpChar(c: Char): Boolean

Returns true if c an operator character.

def isOpType(cat: Int): Boolean

def isScalaIDChar(c: Char): Boolean

Returns true if c is a letter, digit, or an underscore _.

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

Presents a literal String s as a Parser that only parses that exact text and provides it as the result.

implicit def literal(ch: Char): Parser[Char]

Presents a single Char ch as a Parser that only parses that exact character.

implicit def literalRichCharParser(c: Char): RichParser[Char]

implicit def literalRichStringParser(s: String): RichParser[String]

def mapOrFail[S, T](p: Parser[S])(f: (S) ⇒ T): Parser[T]

Applies f to the result of p, transforming any exception when evaluating f into a parse failure with the exception toString as the message.

def matched(t: Parser[_], seen: Vector[Char] = Vector.empty, partial: Boolean = false): Parser[String]

def matches(p: Parser[_], s: String): Boolean

Applies parser p to input s and returns true if the parse was successful.

final def ne(arg0: AnyRef): Boolean

def not(p: Parser[_], failMessage: String): Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def oneOf[T](p: Seq[Parser[T]]): Parser[T]

def opOrIDSpaced(s: String): Parser[Char]

def parse[T](str: String, parser: Parser[T]): Either[String, T]

Parses input str using parser.

implicit def range(r: NumericRange[Char]): Parser[Char]

Presents a Char range as a Parser.

def rep1sep[T](rep: Parser[T], sep: Parser[_]): Parser[Seq[T]]

Applies rep one or more times, separated by sep.

def repeatDep[A](p: (Seq[A]) ⇒ Parser[A], sep: Parser[Any]): Parser[Seq[A]]

Defines a sequence parser where the parser used for each part depends on the previously parsed values.

def repsep[T](rep: Parser[T], sep: Parser[_]): Parser[Seq[T]]

Applies rep zero or more times, separated by sep.

def result[T](p: Parser[T], s: String): Either[() ⇒ (Seq[String], Int), T]

implicit def richParser[A](a: Parser[A]): RichParser[A]

Provides combinators for Parsers.

def sample(str: String, parser: Parser[_], completions: Boolean = false): Unit

Convenience method to use when developing a parser.

def sampleCompletions(str: String, parser: Parser[_], level: Int = 1): Unit

Convenience method to use when developing a parser.

def sampleParse(str: String, parser: Parser[_]): Unit

Convenience method to use when developing a parser.

def seq[T](p: Seq[Parser[T]]): Parser[Seq[T]]

def seq0[T](p: Seq[Parser[T]], errors: ⇒ Seq[String]): Parser[Seq[T]]

def some[T](p: Parser[T]): Parser[Option[T]]

Wraps the result of p in Some.

def spaceDelimited(display: String): Parser[Seq[String]]

Parses a space-delimited, possibly empty sequence of arguments.

def stringLiteral(s: String, start: Int): Parser[String]

def success[T](value: T): Parser[T]

Defines a parser that always succeeds on empty input with the result value.

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

def toString(): String

def token[T](t: Parser[T], complete: TokenCompletions): Parser[T]

def token[T](t: Parser[T], description: String): Parser[T]

Establishes delegate parser t as a single token of tab completion.

def token[T](t: Parser[T], hide: (Int) ⇒ Boolean): Parser[T]

Establishes delegate parser t as a single token of tab completion.

def token[T](t: Parser[T]): Parser[T]

Establishes delegate parser t as a single token of tab completion.

def tokenDisplay[T](t: Parser[T], display: String): Parser[T]

Establishes delegate parser t as a single token of tab completion.

def trimmed(p: Parser[String]): Parser[String]

Applies String.

def validID(s: String): Boolean

Returns true if s parses successfully according to ID.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

object ~

See unapply.

def not(p: Parser[_]): Parser[Unit]

def token[T](t: Parser[T], seen: String, track: Boolean, hide: (Int) ⇒ Boolean): Parser[T]