Parsers

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

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

Definition Classes
AnyRef → Any
lazy val BackslashChar: Char

Backslash character.
Backslash character.

Definition Classes
Parsers
lazy val Bool: Parser[Boolean]

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

Definition Classes
Parsers
lazy val DQuoteChar: Char

Double quote character.
Double quote character.

Definition Classes
Parsers
lazy val DQuoteClass: Parser[Char]

Matches a single double quote.
Matches a single double quote.

Definition Classes
Parsers
lazy val Digit: Parser[Char]

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

Definition Classes
Parsers
lazy val DigitSet: Set[String]

Set that contains each digit in a String representation.
Set that contains each digit in a String representation.

Definition Classes
Parsers
lazy val EOF: Parser[Unit]

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

Definition Classes
Parsers
lazy val EscapeSequence: Parser[Char]

Parses a single escape sequence into the represented Char.
Parses a single escape sequence into the represented Char. Escapes start with a backslash and are followed by u for a UnicodeEscape or by b, t, n, f, r, ", ', \ for standard escapes.

Definition Classes
Parsers
lazy val HexDigit: Parser[Char]

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

Definition Classes
Parsers
lazy val HexDigitSet: Set[Char]

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

Definition Classes
Parsers
lazy val ID: Parser[String]

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

Definition Classes
Parsers
lazy val IDChar: Parser[Char]

Parses an identifier Char other than the first character.
Parses an identifier Char other than the first character. This includes letters, digits, dash -, and underscore _.

Definition Classes
Parsers
def IDStart: Parser[Char]

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

Definition Classes
Parsers
lazy val IntBasic: Parser[Int]

Parses a signed integer.
Parses a signed integer.

Definition Classes
Parsers
lazy val Letter: Parser[Char]

Parses a single letter, according to Char.isLetter, into a Char.
Parses a single letter, according to Char.isLetter, into a Char.

Definition Classes
Parsers
lazy val NatBasic: Parser[Int]

Parses an unsigned integer.
Parses an unsigned integer.

Definition Classes
Parsers
lazy val NotDQuoteBackslashClass: Parser[Char]

Matches any character except a double quote or backslash.
Matches any character except a double quote or backslash.

Definition Classes
Parsers
lazy val NotDQuoteSpaceClass: Parser[Char]

Matches any character except a double quote or whitespace.
Matches any character except a double quote or whitespace.

Definition Classes
Parsers
lazy val NotQuoted: Parser[String]

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

Definition Classes
Parsers
lazy val NotSpace: Parser[String]

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

Definition Classes
Parsers
lazy val NotSpaceClass: Parser[Char]

Matches a single character that is not a whitespace character.
Matches a single character that is not a whitespace character.

Definition Classes
Parsers
lazy val Op: Parser[String]

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

Definition Classes
Parsers
lazy val OpChar: Parser[Char]

Parses a single operator Char, as allowed by isOpChar.
Parses a single operator Char, as allowed by isOpChar.

Definition Classes
Parsers
lazy val OpOrID: Parser[String]

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

Definition Classes
Parsers
lazy val OptNotSpace: Parser[String]

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

Definition Classes
Parsers
lazy val OptSpace: Parser[Seq[Char]]

Matches a possibly empty String consisting of whitespace characters.
Matches a possibly empty String consisting of whitespace characters. The suggested tab completion is a single, constant space character.

Definition Classes
Parsers
lazy val Port: Parser[Int]

Parses a port number.
Parses a port number. Currently, this accepts any integer and presents a tab completion suggestion of <port>.

Definition Classes
Parsers
lazy val ScalaID: Parser[String]

Parses a non-symbolic Scala-like identifier.
Parses a non-symbolic Scala-like identifier. The identifier must start with IDStart and contain zero or more ScalaIDChars after that.

Definition Classes
Parsers
lazy val ScalaIDChar: Parser[Char]

Parses a single, non-symbolic Scala identifier Char.
Parses a single, non-symbolic Scala identifier Char. Valid characters are letters, digits, and the underscore character _.

Definition Classes
Parsers
lazy val Space: Parser[Seq[Char]]

Matches a non-empty String consisting of whitespace characters.
Matches a non-empty String consisting of whitespace characters. The suggested tab completion is a single, constant space character.

Definition Classes
Parsers
lazy val SpaceClass: Parser[Char]

Matches a single whitespace character, as determined by Char.isWhitespace.
Matches a single whitespace character, as determined by Char.isWhitespace.

Definition Classes
Parsers
lazy val StringBasic: Parser[String]

Parses a potentially quoted String value.
Parses a potentially quoted String value. The value may be verbatim quoted (StringVerbatim), quoted with interpreted escapes (StringEscapable), or unquoted (NotQuoted).

Definition Classes
Parsers
lazy val StringEscapable: Parser[String]

Parses a string value, interpreting escapes and discarding the surrounding quotes in the result.
Parses a string value, interpreting escapes and discarding the surrounding quotes in the result. See EscapeSequence for supported escapes.

Definition Classes
Parsers
lazy val StringVerbatim: Parser[String]

Parses a verbatim quoted String value, discarding the quotes in the result.
Parses a verbatim quoted String value, discarding the quotes in the result. This kind of quoted text starts with triple quotes """ and ends at the next triple quotes and may contain any character in between.

Definition Classes
Parsers
lazy val URIChar: Parser[Char]

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

Definition Classes
Parsers
lazy val URIClass: Parser[String]

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

Definition Classes
Parsers
lazy val UnicodeEscape: Parser[Char]

Parses a single unicode escape sequence into the represented Char.
Parses a single unicode escape sequence into the represented Char. A unicode escape begins with a backslash, followed by a u and 4 hexadecimal digits representing the unicode value.

Definition Classes
Parsers
def Uri(ex: Set[URI]): Parser[URI]

Parses a URI that is valid according to the single argument java.net.URI constructor, using ex as tab completion examples.
Parses a URI that is valid according to the single argument java.net.URI constructor, using ex as tab completion examples.

Definition Classes
Parsers
lazy val VerbatimDQuotes: String

Triple-quotes, as used for verbatim quoting.
Triple-quotes, as used for verbatim quoting.

Definition Classes
Parsers
def alphanum(c: Char): Boolean

Returns true if c is an ASCII letter or digit.
Returns true if c is an ASCII letter or digit.

Definition Classes
Parsers
lazy val any: Parser[Char]

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

Definition Classes
Parsers
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val basicUri: Parser[URI]

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

Definition Classes
Parsers
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def fileParser(base: File): Parser[File]

base
the directory used for completion proposals (when the user presses the TAB key). Only paths under this directory will be proposed.
returns
the file that was parsed from the input string. The returned path may or may not exist.

Definition Classes
Parsers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
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.
Applies p and uses true as the result if it succeeds and turns failure into a result of false.

Definition Classes
Parsers
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
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.
Parses a String that starts with start and is followed by zero or more characters parsed by rep.

Definition Classes
Parsers
def isDelimiter(c: Char): Boolean

Definition Classes
Parsers
def isIDChar(c: Char): Boolean

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

Definition Classes
Parsers
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isOpChar(c: Char): Boolean

Returns true if c an operator character.
Returns true if c an operator character.

Definition Classes
Parsers
def isOpType(cat: Int): Boolean

Definition Classes
Parsers
def isScalaIDChar(c: Char): Boolean

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

Definition Classes
Parsers
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.
Applies f to the result of p, transforming any exception when evaluating f into a parse failure with the exception toString as the message.

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 opOrIDSpaced(s: String): Parser[Char]

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

Applies rep one or more times, separated by sep.
Applies rep one or more times, separated by sep. The result is the non-empty sequence of results from the multiple rep applications. The sep results are discarded.

Definition Classes
Parsers
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.
Defines a sequence parser where the parser used for each part depends on the previously parsed values. p is applied to the (possibly empty) sequence of already parsed values to obtain the next parser to use. The parsers obtained in this way are separated by sep, whose result is discarded and only the sequence of values from the parsers returned by p is used for the result.

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

Applies rep zero or more times, separated by sep.
Applies rep zero or more times, separated by sep. The result is the (possibly empty) sequence of results from the multiple rep applications. The sep results are discarded.

Definition Classes
Parsers
def some[T](p: Parser[T]): Parser[Option[T]]

Wraps the result of p in Some.
Wraps the result of p in Some.

Definition Classes
Parsers
def spaceDelimited(display: String): Parser[Seq[String]]

Parses a space-delimited, possibly empty sequence of arguments.
Parses a space-delimited, possibly empty sequence of arguments. The arguments may use quotes and escapes according to StringBasic.

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

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def trimmed(p: Parser[String]): Parser[String]

Applies String.trim to the result of p.
Applies String.trim to the result of p.

Definition Classes
Parsers
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( ... )

Related Docs: trait Parsers | package complete

object Parsers extends Parsers

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val BackslashChar: Char

lazy val Bool: Parser[Boolean]

lazy val DQuoteChar: Char

lazy val DQuoteClass: Parser[Char]

lazy val Digit: Parser[Char]

lazy val DigitSet: Set[String]

lazy val EOF: Parser[Unit]

lazy val EscapeSequence: Parser[Char]

lazy val HexDigit: Parser[Char]

lazy val HexDigitSet: Set[Char]

lazy val ID: Parser[String]

lazy val IDChar: Parser[Char]

def IDStart: Parser[Char]

lazy val IntBasic: Parser[Int]

lazy val Letter: Parser[Char]

lazy val NatBasic: Parser[Int]

lazy val NotDQuoteBackslashClass: Parser[Char]

lazy val NotDQuoteSpaceClass: Parser[Char]

lazy val NotQuoted: Parser[String]

lazy val NotSpace: Parser[String]

lazy val NotSpaceClass: Parser[Char]

lazy val Op: Parser[String]

lazy val OpChar: Parser[Char]

lazy val OpOrID: Parser[String]

lazy val OptNotSpace: Parser[String]

lazy val OptSpace: Parser[Seq[Char]]

lazy val Port: Parser[Int]

lazy val ScalaID: Parser[String]

lazy val ScalaIDChar: Parser[Char]

lazy val Space: Parser[Seq[Char]]

lazy val SpaceClass: Parser[Char]

lazy val StringBasic: Parser[String]

lazy val StringEscapable: Parser[String]

lazy val StringVerbatim: Parser[String]

lazy val URIChar: Parser[Char]

lazy val URIClass: Parser[String]

lazy val UnicodeEscape: Parser[Char]

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

lazy val VerbatimDQuotes: String

def alphanum(c: Char): Boolean

lazy val any: Parser[Char]

final def asInstanceOf[T0]: T0

lazy val basicUri: Parser[URI]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

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

final def getClass(): Class[_]

def hashCode(): Int

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

def isDelimiter(c: Char): Boolean

def isIDChar(c: Char): Boolean

final def isInstanceOf[T0]: Boolean

def isOpChar(c: Char): Boolean

def isOpType(cat: Int): Boolean

def isScalaIDChar(c: Char): Boolean

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

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

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

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

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

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

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

def toString(): String

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

final def wait(): Unit

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