Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##(): Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  lazy val BackslashChar: Char

   Backslash character.

5.  lazy val Bool: Parser[Boolean]

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

6.  lazy val CapitalizedID: Parser[String]

   Parses a non-symbolic Scala-like identifier.

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

7.  lazy val DQuoteChar: Char

   Double quote character.

8.  lazy val DQuoteClass: Parser[Char]

   Matches a single double quote.

9.  lazy val Digit: Parser[Char]

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

10.  lazy val DigitSet: Set[String]

    Set that contains each digit in a String representation.

11.  lazy val EOF: Parser[Unit]

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

12.  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.

13.  lazy val HexDigit: Parser[Char]

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

14.  lazy val HexDigitSet: Set[Char]

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

15.  lazy val ID: Parser[String]

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

16.  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 _.

17.  def IDStart: Parser[Char]

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

18.  lazy val IntBasic: Parser[Int]

    Parses a signed integer.

19.  lazy val Letter: Parser[Char]

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

20.  lazy val Lower: Parser[Char]

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

21.  lazy val NatBasic: Parser[Int]

    Parses an unsigned integer.

22.  lazy val NotDQuoteBackslashClass: Parser[Char]

    Matches any character except a double quote or backslash.

23.  lazy val NotDQuoteSpaceClass: Parser[Char]

    Matches any character except a double quote or whitespace.

24.  lazy val NotQuoted: Parser[String]

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

25.  lazy val NotQuotedThenQuoted: Parser[String]

    Parses a non-empty String value that cannot start with a double quote, but includes double quotes.

26.  lazy val NotSpace: Parser[String]

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

27.  lazy val NotSpaceClass: Parser[Char]

    Matches a single character that is not a whitespace character.

28.  lazy val Op: Parser[String]

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

29.  lazy val OpChar: Parser[Char]

    Parses a single operator Char, as allowed by isOpChar.

30.  lazy val OpOrID: Parser[String]

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

31.  lazy val OptNotSpace: Parser[String]

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

32.  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.

33.  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>.

34.  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.

35.  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 _.

36.  lazy val Size: Parser[Long]

    Parses a size unit string.

    Parses a size unit string. For example, 128K parsers to 128L * 1024, and 1.25g parses to 1024L * 1024 * 1024 * 5 / 4.

37.  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.

38.  lazy val SpaceClass: Parser[Char]

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

39.  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).

40.  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.

41.  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.

42.  lazy val URIChar: Parser[Char]

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

43.  lazy val URIClass: Parser[String]

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

44.  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.

45.  lazy val Upper: Parser[Char]

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

46.  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.

47.  lazy val VerbatimDQuotes: String

    Triple-quotes, as used for verbatim quoting.

48.  def alphanum(c: Char): Boolean

    Returns true if c is an ASCII letter or digit.

49.  lazy val any: Parser[Char]

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

50.  final def asInstanceOf[T0]: T0

    Definition Classes

    Any

51.  lazy val basicUri: Parser[URI]

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

52.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

53.  final def eq(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

54.  def equals(arg0: Any): Boolean

    Definition Classes

    AnyRef → Any

55.  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.

56.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( classOf[java.lang.Throwable] )

57.  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.

58.  final def getClass(): Class[_]

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

59.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

60.  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.

61.  def isDelimiter(c: Char): Boolean
62.  def isIDChar(c: Char): Boolean

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

63.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

64.  def isOpChar(c: Char): Boolean

    Returns true if c an operator character.

65.  def isOpType(cat: Int): Boolean
66.  def isScalaIDChar(c: Char): Boolean

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

67.  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.

68.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

69.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

70.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

71.  def opOrIDSpaced(s: String): Parser[Char]
72.  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.

73.  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.

74.  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.

75.  def some[T](p: Parser[T]): Parser[Option[T]]

    Wraps the result of p in Some.

76.  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.

77.  final def synchronized[T0](arg0: ⇒ T0): T0

    Definition Classes

    AnyRef

78.  def toString(): String

    Definition Classes

    AnyRef → Any

79.  def trimmed(p: Parser[String]): Parser[String]

    Applies String.trim to the result of p.

80.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

82.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()