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 attempt[A](p: Parsley[A]): Parsley[A]

   This combinator parses its argument p, but rolls back any consumed input on failure.

   This combinator parses its argument p, but rolls back any consumed input on failure.

   If the parser p succeeds, then attempt(p) has no effect. However, if p failed, then any input that it consumed is rolled back. This has two uses: it ensures that the parser p is all-or-nothing when consuming input (atomic), and it allows for parsers that consume input to backtrack when they fail (with <|>). It should be used for the latter purpose sparingly, however, since excessive backtracking in a parser can result in much lower efficiency.

   p

   the parser to execute, if it fails, it will not have consumed input.

   returns

   a parser that tries p, but never consumes input if it fails.

   Example:

   1. scala> import parsley.character.string, parsley.Parsley.attempt
      scala> (string("abc") <|> string("abd")).parse("abd")
      val res0 = Failure(..) // first parser consumed a, so no backtrack
      scala> (attempt(string("abc")) <|> string("abd")).parse("abd")
      val res1 = Success("abd") // first parser does not consume input on failure now

6.  def branch[A, B, C](either: Parsley[Either[A, B]], left: ⇒ Parsley[(A) ⇒ C], right: ⇒ Parsley[(B) ⇒ C]): Parsley[C]

   This combinator parses its first argument either, and then parses either left or right depending on its result.

   This combinator parses its first argument either, and then parses either left or right depending on its result.

   First, branch(either, left, right) parses either, which, if successful, will produce either a Left(x) or a Right(y). If a Left(x) is produced, the parser left is executed to produce a function f, and f(x) is returned. Otherwise, if a Right(y) is produced, the parser right is executed to produce a function g, and g(y) is returned. If either of the two executed parsers fail, the entire combinator fails.

   First introduced in Selective Applicative Functors (Mokhov et al. 2019).

   either

   the first parser to execute, its result decides which parser to execute next.

   left

   a parser to execute if either returns a Left.

   right

   a parser to execute if either returns a Right.

   returns

   a parser that will parse one of left or right depending on either's result.

   Example:

   1. def ifP[A](b: Parsley[Boolean], t: =>Parsley[A], e: =>Parsley[A]): Parsley[A] = {
          val cond = b.map {
              case true => Left(())
              case false => Right(())
          }
          branch(cond, t.map[Unit => A](x => _ => x), e.map[Unit => A](x => _ => x))
      }

7.  def clone(): AnyRef

   Attributes

   protected[lang]

   Definition Classes

   AnyRef

   Annotations

   @throws( ... ) @native()

8.  def col: Parsley[Int]

   This parser returns the current column number of the input without having any other effect.

   This parser returns the current column number of the input without having any other effect.

   When this combinator is ran, no input is required, nor consumed, and the current column number will always be successfully returned. It has no other effect on the state of the parser.

   returns

   a parser that returns the column number the parser is currently at.

   Example:

   1. scala> import parsley.Parsley.col, parsley.character.char
      scala> col.parse("")
      val res0 = Success(1)
      scala> (char('a') *> col).parse("a")
      val res0 = Success(2)
      scala> (char('\n') *> col).parse("\n")
      val res0 = Success(1)

   Note

   in the presence of wide unicode characters, the value returned may be inaccurate.

9.  val empty: Parsley[Nothing]

   This parser fails immediately, with an unknown parse error.

   This parser fails immediately, with an unknown parse error.

   returns

   a parser that fails.

   Example:

   1. scala> import parsley.Parsley.empty
      scala> empty.parse("")
      val res0 = Failure(..)

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

    Definition Classes

    AnyRef

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

    Definition Classes

    AnyRef → Any

12.  def finalize(): Unit

    Attributes

    protected[lang]

    Definition Classes

    AnyRef

    Annotations

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

13.  def fresh[A](x: ⇒ A): Parsley[A]

    This combinator produces a new value everytime it is parsed without having any other effect.

    This combinator produces a new value everytime it is parsed without having any other effect.

    When this combinator is ran, no input is required, nor consumed, and a new instance of the given value will always be successfully returned. It has no other effect on the state of the parser.

    This is useful primarily if mutable data is being threaded around a parser: this should not be needed for the vast majority of parsers.

    x

    the value to be returned.

    returns

    a parser which consumes no input and produces a value x.

    Example:

    1. scala> import parsley.Parsley.{pure, fresh}
       scala> val p = pure(new Object)
       scala> p.parse("")
       val res0 = Success(java.lang.Object@44a3ec6b)
       scala> p.parse("")
       val res1 = Success(java.lang.Object@44a3ec6b)
       scala> val q = fresh(new Object)
       scala> q.parse("")
       val res2 = Success(java.lang.Object@71623278)
       scala> q.parse("")
       val res3 = Success(java.lang.Object@768b970c)

    Since

    4.0.0

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

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

15.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

16.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

17.  def join[A](p: Parsley[Parsley[A]]): Parsley[A]

    This combinator collapses two layers of parsing structure into one.

    This combinator collapses two layers of parsing structure into one.

    Just an alias for _.flatten, providing a namesake to Haskell.

    See also

    flatten for details and examples.

18.  def line: Parsley[Int]

    This parser returns the current line number of the input without having any other effect.

    This parser returns the current line number of the input without having any other effect.

    When this combinator is ran, no input is required, nor consumed, and the current line number will always be successfully returned. It has no other effect on the state of the parser.

    returns

    a parser that returns the line number the parser is currently at.

    Example:

    1. scala> import parsley.Parsley.line, parsley.character.char
       scala> line.parse("")
       val res0 = Success(1)
       scala> (char('a') *> line).parse("a")
       val res0 = Success(1)
       scala> (char('\n') *> line).parse("\n")
       val res0 = Success(2)

19.  def lookAhead[A](p: Parsley[A]): Parsley[A]

    This combinator parses its argument p, but does not consume input if it succeeds.

    This combinator parses its argument p, but does not consume input if it succeeds.

    If the parser p succeeds, then lookAhead(p) will roll back any input consumed whilst parsing p. If p fails, however, then the whole combinator fails and any input consumed remains consumed. If this behaviour is not desirable, consider pairing lookAhead with attempt.

    p

    the parser to execute, if it succeeds, it will not have consumed input.

    returns

    a parser that parses p and never consumes input if it succeeds.

    Example:

    1. scala> import parsley.Parsley.lookAhead, parsley.character.string
       scala> (lookAhead(string("aaa")) *> string("aaa")).parse("aaa")
       val res0 = Success("aaa")
       scala> (lookAhead(string("abc")) <|> string("abd")).parse("abd")
       val res1 = Failure(..) // lookAhead does not roll back input consumed on failure

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

    Definition Classes

    AnyRef

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

    This combinator parses its argument p, and succeeds when p fails and vice-versa, never consuming input.

    This combinator parses its argument p, and succeeds when p fails and vice-versa, never consuming input.

    If the parser p succeeds, then notFollowedBy(p) will fail, consuming no input. Otherwise, should p fail, then notFollowedBy(p) will succeed, consuming no input and returning ().

    p

    the parser to execute, it should fail in order for this combinator to succeed.

    returns

    a parser which fails when p succeeds and succeeds otherwise, never consuming input.

    Example:

    1. one use for this combinator is to allow for "longest-match" behaviour. For instance, keywords are normally only considered keywords if they are not part of some larger valid identifier (i.e. the keyword "if" should not parse successfully given "ifp"). This can be accomplished as follows:

       import parsley.character.{string, letterOrDigit}
       import parsley.Parsley.notFollowedBy
       def keyword(kw: String): Parsley[Unit] = attempt {
           string(kw) *> notFollowedBy(letterOrDigit)
       }

22.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

23.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

24.  def pos: Parsley[(Int, Int)]

    This parser returns the current line and column numbers of the input without having any other effect.

    This parser returns the current line and column numbers of the input without having any other effect.

    When this combinator is ran, no input is required, nor consumed, and the current line and column number will always be successfully returned. It has no other effect on the state of the parser.

    returns

    a parser that returns the line and column number the parser is currently at.

    Example:

    1. scala> import parsley.Parsley.pos, parsley.character.char
       scala> pos.parse("")
       val res0 = Success((1, 1))
       scala> (char('a') *> pos).parse("a")
       val res0 = Success((1, 2))
       scala> (char('\n') *> pos).parse("\n")
       val res0 = Success((2, 1))

    Note

    in the presence of wide unicode characters, the column value returned may be inaccurate.

25.  def pure[A](x: A): Parsley[A]

    This combinator produces a value without having any other effect.

    This combinator produces a value without having any other effect.

    When this combinator is ran, no input is required, nor consumed, and the given value will always be successfully returned. It has no other effect on the state of the parser.

    x

    the value to be returned.

    returns

    a parser which consumes no input and produces a value x.

    Example:

    1. scala> import parsley.Parsley.pure
       scala> pure(7).parse("")
       val res0 = Success(7)
       scala> pure("hello!").parse("a")
       val res1 = Success("hello!")

26.  def select[A, B](p: Parsley[Either[A, B]], q: ⇒ Parsley[(A) ⇒ B]): Parsley[B]

    This combinator parses its first argument p, then parses q only if p returns a Left.

    This combinator parses its first argument p, then parses q only if p returns a Left.

    First, select(p, q) parses p, which, if successful, will produce either a Left(x) or a Right(y). If a Left(x) is produced, then the parser q is executed to produce a function f, and f(x) is returned. Otherwise, if a Right(y) is produced, y is returned unmodified and q is not parsed. If either p or q fails, the entire combinator fails. This is a special case of branch where the right branch is pure(identity[B]).

    First introduced in Selective Applicative Functors (Mokhov et al. 2019).

    p

    the first parser to execute, its result decides whether q is executed or not.

    q

    a parser to execute when p returns a Left.

    returns

    a parser that will parse p then possibly parse q to transform p's result into a B.

    Example:

    1. def filter(pred: A => Boolean): Parsley[A] = {
           val p = this.map(x => if (pred(x)) Right(x) else Left(()))
           select(p, empty)
       }

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

    Definition Classes

    AnyRef

28.  def toString(): String

    Definition Classes

    AnyRef → Any

29.  val unit: Parsley[Unit]

    This combinator produces () without having any other effect.

    This combinator produces () without having any other effect.

    When this combinator is ran, no input is required, nor consumed, and the given value will always be successfully returned. It has no other effect on the state of the parser.

    returns

    a parser which consumes no input and produces ().

    Example:

    1. scala> import parsley.Parsley.unit
       scala> unit.parse("")
       val res0 = Success(())
       scala> unit.parse("a")
       val res0 = Success(())

    Note

    defined as pure(()) as a simple convenience.

30.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... )

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

    Definition Classes

    AnyRef

    Annotations

    @throws( ... ) @native()