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.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

5.  def attemptChoice[A](ps: Parsley[A]*): Parsley[A]

   attemptChoice(ps) tries to apply the parsers in the list ps in order, until one of them succeeds.

   attemptChoice(ps) tries to apply the parsers in the list ps in order, until one of them succeeds. Returns the value of the succeeding parser. Utilises <\> vs choice's <|>.

6.  def between[A](open: ⇒ Parsley[_], close: ⇒ Parsley[_], p: ⇒ Parsley[A]): Parsley[A]

   between(open, close, p) parses open, followed by p and close.

   between(open, close, p) parses open, followed by p and close. Returns the value returned by p.

7.  def chainPost[A](p: ⇒ Parsley[A], op: ⇒ Parsley[(A) ⇒ A]): Parsley[A]

   chainPost(p, op) parses one occurrence of p, followed by many postfix applications of op that associate to the left.

8.  def chainPre[A](op: ⇒ Parsley[(A) ⇒ A], p: ⇒ Parsley[A]): Parsley[A]

   chainPre(op, p) parses many prefixed applications of op onto a single final result of p

9.  def chainl[A, B](p: ⇒ Parsley[A], op: ⇒ Parsley[(B, A) ⇒ B], x: B)(implicit wrap: (A) ⇒ B): Parsley[B]

   chainl(p, op, x) parses *zero* or more occurrences of p, separated by op.

   chainl(p, op, x) parses *zero* or more occurrences of p, separated by op. Returns a value obtained by a left associative application of all functions returned by op to the values returned by p. If there are no occurrences of p, the value x is returned.

10.  def chainl1[A, B](p: ⇒ Parsley[A], op: ⇒ Parsley[(B, A) ⇒ B])(implicit wrap: (A) ⇒ B): Parsley[B]

    chainl1(p, op) parses *one* or more occurrences of p, separated by op.

    chainl1(p, op) parses *one* or more occurrences of p, separated by op. Returns a value obtained by a left associative application of all functions return by op to the values returned by p. This parser can for example be used to eliminate left recursion which typically occurs in expression grammars.

11.  def chainr[A, B](p: ⇒ Parsley[A], op: ⇒ Parsley[(A, B) ⇒ B], x: B)(implicit wrap: (A) ⇒ B): Parsley[B]

    chainr(p, op, x) parses *zero* or more occurrences of p, separated by op.

    chainr(p, op, x) parses *zero* or more occurrences of p, separated by op. Returns a value obtained by a right associative application of all functions return by op to the values returned by p. If there are no occurrences of p, the value x is returned.

12.  def chainr1[A, B](p: ⇒ Parsley[A], op: ⇒ Parsley[(A, B) ⇒ B])(implicit wrap: (A) ⇒ B): Parsley[B]

    chainr1(p, op) parses *one* or more occurrences of p, separated by op.

    chainr1(p, op) parses *one* or more occurrences of p, separated by op. Returns a value obtained by a right associative application of all functions return by op to the values returned by p.

13.  def choice[A](ps: Parsley[A]*): Parsley[A]

    choice(ps) tries to apply the parsers in the list ps in order, until one of them succeeds.

    choice(ps) tries to apply the parsers in the list ps in order, until one of them succeeds. Returns the value of the succeeding parser.

14.  def clone(): AnyRef

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

15.  def decide[A](p: ⇒ Parsley[Option[A]], q: ⇒ Parsley[A]): Parsley[A]

    decide(p, q) removes the option from inside parser p, if it returned None then q is executed.

16.  def decide[A](p: ⇒ Parsley[Option[A]]): Parsley[A]

    decide(p) removes the option from inside parser p, and if it returned None will fail.

17.  def endBy[A, B](p: ⇒ Parsley[A], sep: ⇒ Parsley[B]): Parsley[List[A]]

    endBy(p, sep) parses *zero* or more occurrences of p, separated and ended by sep.

    endBy(p, sep) parses *zero* or more occurrences of p, separated and ended by sep. Returns a list of values returned by p.

18.  def endBy1[A, B](p: ⇒ Parsley[A], sep: ⇒ Parsley[B]): Parsley[List[A]]

    endBy1(p, sep) parses *one* or more occurrences of p, separated and ended by sep.

    endBy1(p, sep) parses *one* or more occurrences of p, separated and ended by sep. Returns a list of values returned by p.

19.  val eof: Parsley[Unit]

    This parser only succeeds at the end of the input.

    This parser only succeeds at the end of the input. This is a primitive parser.

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

    Definition Classes

    AnyRef

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

    Definition Classes

    AnyRef → Any

22.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

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

23.  def forP[A](v: Var, init: ⇒ Parsley[A], cond: ⇒ Parsley[(A) ⇒ Boolean], step: ⇒ Parsley[(A) ⇒ A], body: ⇒ Parsley[_]): Parsley[Unit]

    forP(v, init, cond, step, body) behaves much like a traditional for loop using variable v as the loop variable and init, cond, step and body as parsers which control the loop itself.

    forP(v, init, cond, step, body) behaves much like a traditional for loop using variable v as the loop variable and init, cond, step and body as parsers which control the loop itself. This is useful for performing certain context sensitive tasks. For instance, to read an equal number of as, bs and cs you can do:

    put(v1, 0) *>
    many('a' *> modify[Int](v1, _+1)) *>
    forP[Int](v2, get[Int](v1), pure(_ != 0), pure(_ - 1), 'b') *>
    forP[Int](v2, get[Int](v1), pure(_ != 0), pure(_ - 1), 'c')

    The value of v is reset on exiting this parser. This is to preserve the limited register numbers.

    v

    The address the induction variable is stored in

    init

    The initial value that register v should take

    cond

    The condition by which the loop terminates

    step

    The change in induction variable on each iteration

    body

    The body of the loop performed each iteration

    returns

    ()

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

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

25.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

26.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

27.  def manyN[A](n: Int, p: ⇒ Parsley[A]): Parsley[List[A]]

    manyN(n, p) applies the parser p *n* or more times.

    manyN(n, p) applies the parser p *n* or more times. Returns a list of the returned values of p.

28.  def manyUntil[A, B](p: ⇒ Parsley[A], end: ⇒ Parsley[B]): Parsley[List[A]]

    manyUntil(p, end) applies parser p zero or more times until the parser end succeeds.

    manyUntil(p, end) applies parser p zero or more times until the parser end succeeds. Returns a list of values returned by p. This parser can be used to scan comments.

29.  val more: Parsley[Unit]

    This parser only succeeds if there is still more input.

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

    Definition Classes

    AnyRef

31.  def notFollowedBy(p: Parsley[_]): Parsley[Unit]

    notFollowedBy(p) only succeeds when parser p fails.

    notFollowedBy(p) only succeeds when parser p fails. This parser does not consume any input. This parser can be used to implement the 'longest match' rule. For example, when recognising keywords, we want to make sure that a keyword is not followed by a legal identifier character, in which case the keyword is actually an identifier. We can program this behaviour as follows:

    attempt(kw *> notFollowedBy(alphaNum))

32.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

33.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

34.  def option[A](p: ⇒ Parsley[A]): Parsley[Option[A]]

    option(p) tries to apply parser p.

    option(p) tries to apply parser p. If p fails without consuming input, it returns None, otherwise it returns Some of the value returned by p.

35.  def optional(p: ⇒ Parsley[_]): Parsley[Unit]

    optional(p) tries to apply parser p.

    optional(p) tries to apply parser p. It will parse p or nothing. It only fails if p fails after consuming input. It discards the result of p.

36.  def optionally[A](p: ⇒ Parsley[_], x: ⇒ A): Parsley[A]

    optionally(p, x) tries to apply parser p.

    optionally(p, x) tries to apply parser p. It will always result in x regardless of whether or not p succeeded or p failed without consuming input.

37.  def repeat[A](n: Int, p: ⇒ Parsley[A]): Parsley[List[A]]

    repeat(n, p) parses n occurrences of p.

    repeat(n, p) parses n occurrences of p. If n is smaller or equal to zero, the parser is pure(Nil). Returns a list of n values returned by p.

38.  def sepBy[A, B](p: ⇒ Parsley[A], sep: ⇒ Parsley[B]): Parsley[List[A]]

    sepBy(p, sep) parses *zero* or more occurrences of p, separated by sep.

    sepBy(p, sep) parses *zero* or more occurrences of p, separated by sep. Returns a list of values returned by p.

39.  def sepBy1[A, B](p: ⇒ Parsley[A], sep: ⇒ Parsley[B]): Parsley[List[A]]

    sepBy1(p, sep) parses *one* or more occurrences of p, separated by sep.

    sepBy1(p, sep) parses *one* or more occurrences of p, separated by sep. Returns a list of values returned by p.

40.  def sepEndBy[A, B](p: ⇒ Parsley[A], sep: ⇒ Parsley[B]): Parsley[List[A]]

    sepEndBy(p, sep) parses *zero* or more occurrences of p, separated and optionally ended by sep.

    sepEndBy(p, sep) parses *zero* or more occurrences of p, separated and optionally ended by sep. Returns a list of values returned by p.

41.  def sepEndBy1[A, B](p: ⇒ Parsley[A], sep: ⇒ Parsley[B]): Parsley[List[A]]

    sepEndBy1(p, sep) parses *one* or more occurrences of p, separated and optionally ended by sep.

    sepEndBy1(p, sep) parses *one* or more occurrences of p, separated and optionally ended by sep. Returns a list of values returned by p.

42.  def skipManyN[A](n: Int, p: ⇒ Parsley[A]): Parsley[Unit]

    skipManyN(n, p) applies the parser p *n* or more times, skipping its result.

43.  def skipSome[A](p: ⇒ Parsley[A]): Parsley[Unit]

    skipSome(p) applies the parser p *one* or more times, skipping its result.

44.  def some[A](p: ⇒ Parsley[A]): Parsley[List[A]]

    some(p) applies the parser p *one* or more times.

    some(p) applies the parser p *one* or more times. Returns a list of the returned values of p.

45.  def someUntil[A, B](p: ⇒ Parsley[A], end: ⇒ Parsley[B]): Parsley[List[A]]

    someUntil(p, end) applies parser p one or more times until the parser end succeeds.

    someUntil(p, end) applies parser p one or more times until the parser end succeeds. Returns a list of values returned by p.

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

    Definition Classes

    AnyRef

47.  def toString(): String

    Definition Classes

    AnyRef → Any

48.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()

51.  def when(p: ⇒ Parsley[Boolean], q: ⇒ Parsley[Unit]): Parsley[Unit]

    when(p, q) will first perform p, and if the result is true will then execute q or else return unit.

    when(p, q) will first perform p, and if the result is true will then execute q or else return unit.

    p

    The first parser to parse

    q

    If p returns true then this parser is executed

    returns

    ()

52.  def whileP(p: ⇒ Parsley[Boolean]): Parsley[Unit]

    whileP(p) will continue to run p until it returns false.

    whileP(p) will continue to run p until it returns false. This is often useful in conjunction with stateful parsers.

    p

    The parser to continuously execute

    returns

    ()