Packages

  • package root
    Definition Classes
    root
  • package parsley
    Definition Classes
    root
  • object registers

    This module contains all the functionality and operations for using and manipulating registers.

    This module contains all the functionality and operations for using and manipulating registers.

    These often have a role in performing context-sensitive parsing tasks, where a Turing-powerful system is required. While flatMap is capable of such parsing, it is much less efficient than the use of registers, though slightly more flexible. In particular, the persist combinator enabled by RegisterMethods can serve as a drop-in replacement for flatMap in many scenarios.

    Definition Classes
    parsley
    Since

    2.2.0

  • Reg
  • RegisterMaker
  • RegisterMethods
c

parsley.registers

RegisterMethods

implicit final class RegisterMethods[P, A] extends AnyRef

This class, when in scope, enables the use of combinators directly on parsers that interact with the register system to store and persist results so they can be used multiple times.

Source
registers.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. RegisterMethods
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new RegisterMethods(p: P)(implicit con: (P) ⇒ Parsley[A])

    This constructor should not be called manually, it is designed to be used via Scala's implicit resolution.

    This constructor should not be called manually, it is designed to be used via Scala's implicit resolution.

    p

    the value that this class is enabling methods on.

    con

    a conversion that allows values convertible to parsers to be used.

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 clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  8. def fillReg[B](body: (Reg[A]) ⇒ Parsley[B]): Parsley[B]

    This combinator fills a fresh register with the result of this parser, this register is provided to the given function, which continues the parse.

    This combinator fills a fresh register with the result of this parser, this register is provided to the given function, which continues the parse.

    This allows for a more controlled way of creating registers during a parse, without explicitly creating them with Reg.make[A] and using put. These registers are intended to be fresh every time they are "created", in other words, a recursive call with a fillReg call inside will modify a different register each time.

    body

    a function to generate a parser that can interact with the freshly created register.

    Example: 

    1. // this is an efficient implementation for persist.
def persist[B](f: Parsley[A] => Parsley[B]): Parsley[B] = this.fillReg(reg => f(reg.get))
    Since

    4.0.0

  9. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  10. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  12. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  13. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  14. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  15. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  16. def persist[B](f: (Parsley[A]) ⇒ Parsley[B]): Parsley[B]

    This combinator allows for the result of this parser to be used multiple times within a function, without needing to reparse or recompute.

    This combinator allows for the result of this parser to be used multiple times within a function, without needing to reparse or recompute.

    Similar to flatMap, except it is much cheaper to do, at the cost of the restriction that the argument is Parsley[A] and not just A.

    f

    a function to generate a new parser that can observe the result of this parser many times without reparsing.

    Example: 

    1. // this is a reasonable implementation, though direct use of `branch` may be more efficent.
def filter(pred: A => Boolean): Parsley[A] = {
    this.persist(px => ifP(px.map(pred), px, empty))
}
    Since

    3.2.0

  17. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  18. def toString(): String
    Definition Classes
    AnyRef → Any
  19. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  20. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  21. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped