parsley
5.0.0-M3
API
Generated with
parsley/parsley/debug/DebugCombinators

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.

Type parameters

P

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

Value parameters

con

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

p

the value that this class is enabling methods on.

Attributes

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

Value members

Concrete methods

def debug(name: String, break: Breakpoint, colored: Boolean, watchedRefs: (Ref[_], 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 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.

Value parameters

break

The breakpoint properties of this parser, defaults to NoBreak

colored

Whether to render with (default true: render colours)

name

The name to be assigned to this parser

watchedRefs

Which references to also track the values of and their names, if any

Attributes

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, watchedRefs: (Ref[_], 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 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.

Value parameters

break

The breakpoint properties of this parser, defaults to NoBreak

name

The name to be assigned to this parser

watchedRefs

Which references to also track the values of and their names, if any

Attributes

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, colored: Boolean, watchedRefs: (Ref[_], 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 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.

Value parameters

colored

Whether to render with colour

name

The name to be assigned to this parser

watchedRefs

Which references to also track the values of and their names, if any

Attributes

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, watchedRefs: (Ref[_], 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 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.

Value parameters

name

The name to be assigned to this parser

watchedRefs

Which references to also track the values of and their names, if any

Attributes

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, colored: Boolean)(implicit errBuilder: ErrorBuilder[_]): Parsley[A]

Display information about the error messages generated by this parser.

Display information about the error messages generated by this parser.

This is an experimental debugger that provides internal information about error messages. This provides more detail than one might normally see inside a regular error message, but may help isolate the root cause of an error message not being as expected: this can form the bulk of a specific question on the discussion board.

Value parameters

colored

Whether the output should be colourful

errBuilder

The error builder used for formatting messages in the "real parser", which is used to help format information in the debugger.

name

The name to be assigned to this parser

Attributes

Since

4.0.0

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

Display information about the error messages generated by this parser.

Display information about the error messages generated by this parser.

This is an experimental debugger that provides internal information about error messages. This provides more detail than one might normally see inside a regular error message, but may help isolate the root cause of an error message not being as expected: this can form the bulk of a specific question on the discussion board.

Value parameters

colored

Whether the output should be colourful

errBuilder

The error builder used for formatting messages in the "real parser", which is used to help format information in the debugger.

name

The name to be assigned to this parser

Attributes

Since

4.0.0

Source
debug.scala
def profile(name: String)(implicit profiler: Profiler): Parsley[A]

This combinator allows for the runtime of this parser to be measured.

This combinator allows for the runtime of this parser to be measured.

When this parser executes, its start and end times will be logged using System.nanoTime(), which has a resolution of 100ns. These will be logged into the given Profiler object.

Value parameters

name

the unique name of this parser, which will represent it in the table

profiler

the profiling object that will collect and process the data

Attributes

See also
Since

4.4.0

Note

usual disclaimers about profiling apply: results are just data; use your judgement

Source
debug.scala
Generated with