DebugCombinators

parsley.debug$.DebugCombinators
implicit class DebugCombinators[P, A](p: P)(implicit con: P => Parsley[A])

This class enables the debug combinator on parsers.

This extension class operates on values that are convertible to parsers. It enables the use of the debug combinator, which can be used to trace the execution through a parser.

Attributes

P

the type of base value that this class is used on (the conversion to Parsley) is summoned automatically.

con

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

p

the value that this class is enabling methods on.

Constructor:

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

Source:
debug.scala
Graph
Supertypes
class Object
trait Matchable
class Any

Members list

Concise view

Value members

Concrete methods

def debug(name: String, break: Breakpoint, coloured: Boolean): Parsley[A]

This combinator allows this parser to be debugged by providing a trace through the execution.

This combinator allows this parser to be debugged by providing a trace through the execution.

When this combinator is entered, it will print the name assigned to the parser, as well as the current currenting input context for a few characters on either side. This parser is then executed. If it succeeded, this combinator again reports the name along with "Good" and the input context. If it failed, it reports the name along with "Bad" and the input context.

When breakpoints are used, the execution of the combinator will pause on either entry, exit, or both. The parse is resumed by entering a newline on standard input. Breakpoints will cause additional information about the internal state of the parser to be reported.

Attributes

break

The breakpoint properties of this parser, defaults to NoBreak

coloured

Whether to render with colour (default true: render colours)

name

The name to be assigned to this parser

Example:

scala> import parsley.debug.DebugCombinators, parsley.character.string, parsley.Parsley.attempt
scala> val abc = attempt(string("abc").debug("string abc")).debug("attempt")
scala> val abd = string("abd").debug("string abd")
scala> val p = (abc <|> abd).debug("or")
scala> p.parse("abd")
>or> (1, 1): abd•
            ^
 >attempt> (1, 1): abd•
                   ^
   >string abc> (1, 1): abd•
                        ^
   <string abc< (1, 3): abd• Fail
                          ^
 <attempt< (1, 1): abd• Fail
                   ^
 >string abd> (1, 1): abd•
                      ^
 <string abd< (1, 4): abd• Good
                         ^
<or< (1, 4): abd• Good
               ^
val res0 = Success("abd")
Source:
debug.scala
def debug(name: String, break: Breakpoint): Parsley[A]

This combinator allows this parser to be debugged by providing a trace through the execution.

This combinator allows this parser to be debugged by providing a trace through the execution.

When this combinator is entered, it will print the name assigned to the parser, as well as the current currenting input context for a few characters on either side. This parser is then executed. If it succeeded, this combinator again reports the name along with "Good" and the input context. If it failed, it reports the name along with "Bad" and the input context.

When breakpoints are used, the execution of the combinator will pause on either entry, exit, or both. The parse is resumed by entering a newline on standard input. Breakpoints will cause additional information about the internal state of the parser to be reported.

Attributes

break

The breakpoint properties of this parser, defaults to NoBreak

name

The name to be assigned to this parser

Example:

scala> import parsley.debug.DebugCombinators, parsley.character.string, parsley.Parsley.attempt
scala> val abc = attempt(string("abc").debug("string abc")).debug("attempt")
scala> val abd = string("abd").debug("string abd")
scala> val p = (abc <|> abd).debug("or")
scala> p.parse("abd")
>or> (1, 1): abd•
            ^
 >attempt> (1, 1): abd•
                   ^
   >string abc> (1, 1): abd•
                        ^
   <string abc< (1, 3): abd• Fail
                          ^
 <attempt< (1, 1): abd• Fail
                   ^
 >string abd> (1, 1): abd•
                      ^
 <string abd< (1, 4): abd• Good
                         ^
<or< (1, 4): abd• Good
               ^
val res0 = Success("abd")

Renders in colour.

Source:
debug.scala
def debug(name: String, coloured: Boolean): Parsley[A]

This combinator allows this parser to be debugged by providing a trace through the execution.

This combinator allows this parser to be debugged by providing a trace through the execution.

When this combinator is entered, it will print the name assigned to the parser, as well as the current currenting input context for a few characters on either side. This parser is then executed. If it succeeded, this combinator again reports the name along with "Good" and the input context. If it failed, it reports the name along with "Bad" and the input context.

When breakpoints are used, the execution of the combinator will pause on either entry, exit, or both. The parse is resumed by entering a newline on standard input. Breakpoints will cause additional information about the internal state of the parser to be reported.

Attributes

coloured

Whether to render with colour

name

The name to be assigned to this parser

Example:

scala> import parsley.debug.DebugCombinators, parsley.character.string, parsley.Parsley.attempt
scala> val abc = attempt(string("abc").debug("string abc")).debug("attempt")
scala> val abd = string("abd").debug("string abd")
scala> val p = (abc <|> abd).debug("or")
scala> p.parse("abd")
>or> (1, 1): abd•
            ^
 >attempt> (1, 1): abd•
                   ^
   >string abc> (1, 1): abd•
                        ^
   <string abc< (1, 3): abd• Fail
                          ^
 <attempt< (1, 1): abd• Fail
                   ^
 >string abd> (1, 1): abd•
                      ^
 <string abd< (1, 4): abd• Good
                         ^
<or< (1, 4): abd• Good
               ^
val res0 = Success("abd")

No break-points.

Source:
debug.scala
def debug(name: String): Parsley[A]

This combinator allows this parser to be debugged by providing a trace through the execution.

This combinator allows this parser to be debugged by providing a trace through the execution.

When this combinator is entered, it will print the name assigned to the parser, as well as the current currenting input context for a few characters on either side. This parser is then executed. If it succeeded, this combinator again reports the name along with "Good" and the input context. If it failed, it reports the name along with "Bad" and the input context.

When breakpoints are used, the execution of the combinator will pause on either entry, exit, or both. The parse is resumed by entering a newline on standard input. Breakpoints will cause additional information about the internal state of the parser to be reported.

Attributes

name

The name to be assigned to this parser

Example:

scala> import parsley.debug.DebugCombinators, parsley.character.string, parsley.Parsley.attempt
scala> val abc = attempt(string("abc").debug("string abc")).debug("attempt")
scala> val abd = string("abd").debug("string abd")
scala> val p = (abc <|> abd).debug("or")
scala> p.parse("abd")
>or> (1, 1): abd•
            ^
 >attempt> (1, 1): abd•
                   ^
   >string abc> (1, 1): abd•
                        ^
   <string abc< (1, 3): abd• Fail
                          ^
 <attempt< (1, 1): abd• Fail
                   ^
 >string abd> (1, 1): abd•
                      ^
 <string abd< (1, 4): abd• Good
                         ^
<or< (1, 4): abd• Good
               ^
val res0 = Success("abd")

Renders in colour with no break-point.

Source:
debug.scala
def debugError(name: String, coloured: Boolean)(implicit errBuilder: ErrorBuilder[_]): Parsley[A]

Attributes

Source:
debug.scala
def debugError(name: String)(implicit errBuilder: ErrorBuilder[_]): Parsley[A]

Attributes

Source:
debug.scala