Packages

  • package root

    This is the documentation for Parsley.

    This is the documentation for Parsley.

    Package structure

    The parsley package contains the Parsley class, as well as the Result, Success, and Failure types. In addition to these, it also contains the following packages and "modules" (a module is defined as being an object which mocks a package):

    • parsley.Parsley contains the bulk of the core "function-style" combinators, as well as the implicit classes which enable the "method-style" combinators.
    • parsley.combinator contains many helpful combinators that simplify some common parser patterns.
    • parsley.character contains the combinators needed to read characters and strings, as well as combinators to match specific sub-sets of characters.
    • parsley.debug contains debugging combinators, helpful for identifying faults in parsers.
    • parsley.io contains extension methods to run parsers with input sourced from IO sources.
    • parsley.expr contains the following sub modules:
    • parsley.implicits contains several implicits to add syntactic sugar to the combinators. These are sub-categorised into the following sub modules:
      • parsley.implicits.character contains implicits to allow you to use character and string literals as parsers.
      • parsley.implicits.combinator contains implicits related to combinators, such as the ability to make any parser into a Parsley[Unit] automatically.
      • parsley.implicits.lift enables postfix application of the lift combinator onto a function (or value).
      • parsley.implicits.zipped enables boths a reversed form of lift where the function appears on the right and is applied on a tuple (useful when type inference has failed) as well as a .zipped method for building tuples out of several combinators.
    • parsley.errors contains modules to deal with error messages, their refinement and generation.
      • parsley.errors.combinator provides combinators that can be used to either produce more detailed errors as well as refine existing errors.
    • parsley.lift contains functions which lift functions that work on regular types to those which now combine the results of parsers returning those same types. these are ubiquitous.
    • parsley.registers contains combinators that interact with the context-sensitive functionality in the form of registers.
    • parsley.token contains the Lexer class that provides a host of helpful lexing combinators when provided with the description of a language.
    • parsley.unsafe contains unsafe (and not thread-safe) ways of speeding up the execution of a parser.
    Definition Classes
    root
  • package parsley
    Definition Classes
    root
  • package errors
  • package expr
  • package implicits
  • package token
  • Failure
  • Parsley
  • Parsley212
  • Result
  • Success
  • character
  • combinator
  • debug
  • lift
  • registers
  • unsafe
p

parsley

package parsley

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. class Failure[Err] extends Result[Err, Nothing] with Product with Serializable

    Returned on parsing failure

  2. final class Parsley[+A] extends AnyVal

    This is the class that encapsulates the act of parsing and running an object of this class with parse will parse the string given as input to parse.

    This is the class that encapsulates the act of parsing and running an object of this class with parse will parse the string given as input to parse.

    Note: In order to construct an object of this class you must use the combinators; the class itself is opaque.

    Version

    3.0.0

  3. sealed trait Result[+Err, +A] extends AnyRef

    Result of a parser.

    Result of a parser. Either a Success[A] or a Failure

    A

    The type of expected success result

  4. case class Success[A] extends Result[Nothing, A] with Product with Serializable

    Returned when a parser succeeded.

    Returned when a parser succeeded.

    A

    The type of expected success result

Value Members

  1. object Failure extends Serializable
  2. object Parsley

    This object contains the core "function-style" combinators as well as the implicit classes which provide the "method-style" combinators.

    This object contains the core "function-style" combinators as well as the implicit classes which provide the "method-style" combinators. All parsers will likely require something from within!

  3. object Parsley212
  4. object character

    This module contains many parsers to do with reading one or more characters.

    This module contains many parsers to do with reading one or more characters. Almost every parser will need something from this module.

    Since

    2.2.0

  5. object combinator

    This module contains a huge number of pre-made combinators that are very useful for a variety of purposes.

    This module contains a huge number of pre-made combinators that are very useful for a variety of purposes.

    Since

    2.2.0

  6. object debug

    This module contains the very useful debugging combinator, as well as breakpoints.

  7. object lift

    This module contains lift1 through lift22, which allow for the application of a FunctionN to N parsers for example:

    This module contains lift1 through lift22, which allow for the application of a FunctionN to N parsers for example:

    Examples: 

    1. lift2[Int, Int, Int](_+_, px, py): Parsley[Int]
      2. , 

    2. lift3((x: Int, y: Int, z: Int) => x + y + z, px, py, pz): Parsley[Int]
    Since

    2.2.0

  8. 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.

    Since

    2.2.0

  9. object unsafe

    This module contains various things that shouldn't be used without care and caution

    This module contains various things that shouldn't be used without care and caution

    Since

    1.6.0

Ungrouped