laika-core
API
Generated with
laika-core/laika/laika.parse/laika.parse.text/TextParsers

TextParsers

laika.parse.text.TextParsers
See theTextParsers companion object
trait TextParsers extends Parsers

Base text parsers that provide optimized low-level parsers for typical requirements of text markup parsers. In particular they are meant as an efficient replacement for scenarios where usually regex parsers are used. In cases where different parsers need to be tried for relatively short input sequences, regex parsers tend to be less efficient. Furthermore, these base parsers may also improve readability, as it allows to combine simple low-level parsers to higher-level parsers based on the Laika combinator API, instead of producing long regexes which may be hard to read.

Attributes

Companion
object
Graph
Supertypes
trait Parsers
class Object
trait Matchable
class Any
Known subtypes
object TextParsers.type
object builders.type

Members list

Type members

Inherited classlikes

case class ParserException(result: Failure) extends RuntimeException

Attributes

Inherited from:
Parsers
Supertypes
trait Product
trait Equals
class RuntimeException
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
implicit class TryOps[A](t: Try[A])

Provides additional methods to Try via implicit conversion.

Provides additional methods to Try via implicit conversion.

Attributes

Inherited from:
Parsers
Supertypes
class Object
trait Matchable
class Any

Value members

Concrete methods

def anyNot(char: Char, chars: Char*): Characters[String]

Consumes any number of consecutive characters that are not one of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Consumes any number of consecutive characters that are not one of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Attributes

def anyNot(chars: Type[Char]): Characters[String]

Consumes any number of consecutive occurrences that are not one of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Consumes any number of consecutive occurrences that are not one of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Attributes

def anyOf(char: Char, chars: Char*): Characters[String]

Consumes any number of consecutive occurrences of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Consumes any number of consecutive occurrences of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Attributes

def anyOf(chars: Type[Char]): Characters[String]

Consumes any number of consecutive occurrences of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Consumes any number of consecutive occurrences of the specified characters. Always succeeds unless a minimum number of required matches is specified.

Attributes

def anyWhile(p: Char => Boolean): Characters[String]

Consumes any number of consecutive characters which satisfy the specified predicate. Always succeeds unless a minimum number of required matches is specified.

Consumes any number of consecutive characters which satisfy the specified predicate. Always succeeds unless a minimum number of required matches is specified.

Attributes

def delimitedBy(char: Char, chars: Char*): DelimitedText

Consumes any number of consecutive characters until one of the specified characters is encountered on the input string.

Consumes any number of consecutive characters until one of the specified characters is encountered on the input string.

Attributes

def delimitedBy(chars: Type[Char]): DelimitedText

Consumes any number of consecutive characters until one of the specified characters is encountered on the input string.

Consumes any number of consecutive characters until one of the specified characters is encountered on the input string.

Attributes

def delimitedBy(str: String): DelimitedText

Consumes any number of consecutive characters until the specified string delimiter is encountered on the input string.

Consumes any number of consecutive characters until the specified string delimiter is encountered on the input string.

Attributes

def delimitedBy(delimiter: PrefixedParser[String]): DelimitedText

Consumes any number of consecutive characters until the specified delimiter parser succeeds on the input.

Consumes any number of consecutive characters until the specified delimiter parser succeeds on the input.

This constructor is limited to the sub-trait PrefixedParser as only those can be optimized for an assertion that needs to be performed on each character. Most parsers for non-empty text implement this trait, e.g oneOf, someOf, delimiter or the literal parsers for a character or string.

Attributes

def delimiter(char: Char, chars: Char*): DelimiterParser

Creates a parser for a delimiter based on the given set of delimiter characters with an API that allows to specify predicates for the characters immediately preceding or following the delimiter, a common task in markup parsing.

Creates a parser for a delimiter based on the given set of delimiter characters with an API that allows to specify predicates for the characters immediately preceding or following the delimiter, a common task in markup parsing.

Attributes

def delimiter(delim: String): DelimiterParser

Creates a parser for a delimiter based on a literal string with an API that allows to specify predicates for the characters immediately preceding or following the delimiter, a common task in markup parsing.

Creates a parser for a delimiter based on a literal string with an API that allows to specify predicates for the characters immediately preceding or following the delimiter, a common task in markup parsing.

Attributes

def delimiter(parser: PrefixedParser[String]): DelimiterParser

Creates a parser for a delimiter with an API that allows to specify predicates for the characters immediately preceding or following the delimiter, a common task in markup parsing.

Creates a parser for a delimiter with an API that allows to specify predicates for the characters immediately preceding or following the delimiter, a common task in markup parsing.

This specified underlying parser needs to implement the sub-trait PrefixedParser as only those can be optimized for an assertion that needs to be performed on each character. Most parsers for non-empty text implement this trait, e.g oneOf, someOf, delimiter or the literal parsers for a character or string.

Attributes

def literal(expected: String): PrefixedParser[String]

A parser that matches only the specified literal string.

A parser that matches only the specified literal string.

The method is implicit so that strings can automatically be lifted to their parsers.

Attributes

def nextIn(char: Char, chars: Char*): Parser[Unit]

Verifies that the next character is one of those specified. Fails at the end of the input and does not consume any input or produce a result when it succeeds.

Verifies that the next character is one of those specified. Fails at the end of the input and does not consume any input or produce a result when it succeeds.

Attributes

def nextIn(chars: Type[Char]): Parser[Unit]

Verifies that the next character is one of those specified. Fails at the end of the input and does not consume any input or produce a result when it succeeds.

Verifies that the next character is one of those specified. Fails at the end of the input and does not consume any input or produce a result when it succeeds.

Attributes

def nextIs(predicate: Char => Boolean): Parser[Unit]

Verifies that the next character does not satisfy the specified predicate. Fails at the end of the input and does not consume any input or produce a result when it succeeds.

Verifies that the next character does not satisfy the specified predicate. Fails at the end of the input and does not consume any input or produce a result when it succeeds.

Attributes

def nextNot(char: Char, chars: Char*): Parser[Unit]

Verifies that the next character is not one of those specified. Succeeds at the end of the input and does not consume any input or produce a result when it succeeds.

Verifies that the next character is not one of those specified. Succeeds at the end of the input and does not consume any input or produce a result when it succeeds.

Attributes

def nextNot(chars: Type[Char]): Parser[Unit]

Verifies that the next character is not one of those specified. Succeeds at the end of the input and does not consume any input or produce a result when it succeeds.

Verifies that the next character is not one of those specified. Succeeds at the end of the input and does not consume any input or produce a result when it succeeds.

Attributes

def nextNot(predicate: Char => Boolean): Parser[Unit]

Verifies that the next character does not satisfy the specified predicate. Succeeds at the end of the input and does not consume any input or produce a result when it succeeds.

Verifies that the next character does not satisfy the specified predicate. Succeeds at the end of the input and does not consume any input or produce a result when it succeeds.

Attributes

def oneIf(p: Char => Boolean): Parser[String]

Consumes one character if it satisfies the specified predicate, fails otherwise.

Consumes one character if it satisfies the specified predicate, fails otherwise.

Attributes

def oneNot(char: Char, chars: Char*): Parser[String]

Consumes one character if it is not one of the specified characters.

Consumes one character if it is not one of the specified characters.

Attributes

def oneNot(chars: Type[Char]): Parser[String]

Consumes one character if it is not one of the specified characters.

Consumes one character if it is not one of the specified characters.

Attributes

def oneOf(char: Char, chars: Char*): PrefixedParser[String]

Consumes one character if it matches one of the specified characters, fails otherwise.

Consumes one character if it matches one of the specified characters, fails otherwise.

Attributes

def oneOf(chars: Type[Char]): PrefixedParser[String]

Consumes one character if it matches one of the specified characters, fails otherwise.

Consumes one character if it matches one of the specified characters, fails otherwise.

Attributes

def prevIn(char: Char, chars: Char*): Parser[Unit]

Verifies that the previous character is one of those specified. Fails at the start of the input and does not consume any input or produce a result when it succeeds.

Verifies that the previous character is one of those specified. Fails at the start of the input and does not consume any input or produce a result when it succeeds.

Attributes

def prevIn(chars: Type[Char]): Parser[Unit]

Verifies that the previous character is one of those specified. Fails at the start of the input and does not consume any input or produce a result when it succeeds.

Verifies that the previous character is one of those specified. Fails at the start of the input and does not consume any input or produce a result when it succeeds.

Attributes

def prevIs(predicate: Char => Boolean): Parser[Unit]

Verifies that the previous character satisfies the specified predicate. Fails at the start of the input and does not consume any input or produce a result when it succeeds.

Verifies that the previous character satisfies the specified predicate. Fails at the start of the input and does not consume any input or produce a result when it succeeds.

Attributes

def prevNot(char: Char, chars: Char*): Parser[Unit]

Verifies that the previous character is not one of those specified. Succeeds at the start of the input and does not consume any input or produce a result when it succeeds.

Verifies that the previous character is not one of those specified. Succeeds at the start of the input and does not consume any input or produce a result when it succeeds.

Attributes

def prevNot(chars: Type[Char]): Parser[Unit]

Verifies that the previous character is not one of those specified. Succeeds at the start of the input and does not consume any input or produce a result when it succeeds.

Verifies that the previous character is not one of those specified. Succeeds at the start of the input and does not consume any input or produce a result when it succeeds.

Attributes

def prevNot(predicate: Char => Boolean): Parser[Unit]

Verifies that the previous character does not satisfy the specified predicate. Succeeds at the start of the input and does not consume any input or produce a result when it succeeds.

Verifies that the previous character does not satisfy the specified predicate. Succeeds at the start of the input and does not consume any input or produce a result when it succeeds.

Attributes

def range(fromChar: Char, toChar: Char): Type[Char]

Creates a NonEmptySet from a Character range. This set can then be passed to parsers like anyOf or oneOf which expect a NonEmptySet as a parameter.

Creates a NonEmptySet from a Character range. This set can then be passed to parsers like anyOf or oneOf which expect a NonEmptySet as a parameter.

Attributes

def someNot(char: Char, chars: Char*): Characters[String]

Consumes one or more characters that are not one of the specified characters, fails for empty results.

Consumes one or more characters that are not one of the specified characters, fails for empty results.

Attributes

def someNot(chars: Type[Char]): Characters[String]

Consumes one or more characters that are not one of the specified characters, fails for empty results.

Consumes one or more characters that are not one of the specified characters, fails for empty results.

Attributes

def someOf(char: Char, chars: Char*): PrefixCharacters[String]

Consumes one or more characters if they match one of the specified characters, fails if the first character does not match.

Consumes one or more characters if they match one of the specified characters, fails if the first character does not match.

Attributes

def someOf(chars: Type[Char]): PrefixCharacters[String]

Consumes one or more characters if they match one of the specified characters, fails if the first character does not match.

Consumes one or more characters if they match one of the specified characters, fails if the first character does not match.

Attributes

def someWhile(p: Char => Boolean): Characters[String]

Consumes one or more characters which satisfy the specified predicate, fails for empty results.

Consumes one or more characters which satisfy the specified predicate, fails for empty results.

Attributes

Inherited methods

def consumeAll[T](p: Parser[T]): Parser[T]

A parser that succeeds if the specified parser succeeds and all input has been consumed.

A parser that succeeds if the specified parser succeeds and all input has been consumed.

Attributes

Inherited from:
Parsers
def failure(msg: String): Parser[Nothing]

A parser that always fails with the specified message.

A parser that always fails with the specified message.

Attributes

Inherited from:
Parsers
def lazily[T](p: => Parser[T]): Parser[T]

Constructs a parser lazily, useful when breaking circles in recursive parsing.

Constructs a parser lazily, useful when breaking circles in recursive parsing.

Attributes

Inherited from:
Parsers
def lookAhead(offset: Int, value: String): Parser[String]

Attempts to parse the specified literal value at the specified offset behind the current position. Never consumes any input.

Attempts to parse the specified literal value at the specified offset behind the current position. Never consumes any input.

Attributes

Inherited from:
Parsers
def lookAhead[T](offset: Int, p: Parser[T]): Parser[T]

Applies the specified parser at the specified offset behind the current position. Never consumes any input.

Applies the specified parser at the specified offset behind the current position. Never consumes any input.

Attributes

Inherited from:
Parsers
def lookAhead(value: String): Parser[String]

Attempts to parse the specified literal value at the current position. Never consumes any input.

Attempts to parse the specified literal value at the current position. Never consumes any input.

Attributes

Inherited from:
Parsers
def lookAhead[T](p: Parser[T]): Parser[T]

Applies the specified parser at the current position. Never consumes any input.

Applies the specified parser at the current position. Never consumes any input.

Attributes

Inherited from:
Parsers
def lookBehind[T](offset: Int, parser: => Parser[T]): Parser[T]

Applies the specified parser at the specified offset behind the current position. Never consumes any input.

Applies the specified parser at the specified offset behind the current position. Never consumes any input.

Attributes

Inherited from:
Parsers
def not(value: String): Parser[Unit]

A parser that only succeeds if the parsing the specified literal value fails and vice versa, it never consumes any input.

A parser that only succeeds if the parsing the specified literal value fails and vice versa, it never consumes any input.

Attributes

Inherited from:
Parsers
def not[T](p: Parser[T]): Parser[Unit]

A parser that only succeeds if the specified parser fails and vice versa, it never consumes any input.

A parser that only succeeds if the specified parser fails and vice versa, it never consumes any input.

Attributes

Inherited from:
Parsers
def opt(value: String): Parser[Option[String]]

A parser for an optional literal string that always succeeds.

A parser for an optional literal string that always succeeds.

If the underlying parser succeeds this parser will contain its result as a Some, if it fails this parser will succeed with a None.

Attributes

Inherited from:
Parsers
def opt[T](p: Parser[T]): Parser[Option[T]]

A parser for an optional element that always succeeds.

A parser for an optional element that always succeeds.

If the underlying parser succeeds this parser will contain its result as a Some, if it fails this parser will succeed with a None.

Attributes

Inherited from:
Parsers
def success[T](v: T): Parser[T]

A parser that always succeeds with the specified value.

A parser that always succeeds with the specified value.

Attributes

Inherited from:
Parsers

Concrete fields

val anyChars: Characters[String]

Consumes any kind of input, always succeeds. This parser would consume the entire input unless a max constraint is specified.

Consumes any kind of input, always succeeds. This parser would consume the entire input unless a max constraint is specified.

Attributes

val atStart: Parser[Unit]

Succeeds at the start of the input.

Succeeds at the start of the input.

Attributes

val blankLine: Parser[String]

Parses a blank line from the current input offset (which may not be at the start of the line). Fails for lines that contain any non-whitespace character. Does always produce an empty string as the result, discarding any whitespace characters found in the line.

Parses a blank line from the current input offset (which may not be at the start of the line). Fails for lines that contain any non-whitespace character. Does always produce an empty string as the result, discarding any whitespace characters found in the line.

Since it also succeeds at the end of the input it should never be used in the form of (blankLine *) or (blankLine +). Use the blankLines parser instead in these cases.

Attributes

val blankLines: Parser[List[String]]

Parses one or more blank lines, producing a list of empty strings corresponding to the number of blank lines consumed.

Parses one or more blank lines, producing a list of empty strings corresponding to the number of blank lines consumed.

Attributes

val eof: Parser[String]

Succeeds at the end of the input.

Succeeds at the end of the input.

Attributes

val eol: Parser[Unit]

Succeeds at the end of a line, including the end of the input. Produces an empty string as a result and consumes any new line characters.

Succeeds at the end of a line, including the end of the input. Produces an empty string as a result and consumes any new line characters.

Attributes

val oneChar: Parser[String]

Parses exactly one character from the input, fails only at the end of the input.

Parses exactly one character from the input, fails only at the end of the input.

Attributes

val restOfLine: Parser[String]

Parses the rest of the line from the current input offset no matter whether it consist of whitespace only or some text. Does not include the eol character(s).

Parses the rest of the line from the current input offset no matter whether it consist of whitespace only or some text. Does not include the eol character(s).

Attributes

val textLine: Parser[String]

Parses a single text line from the current input offset (which may not be at the start of the line). Fails for blank lines. Does not include the eol character(s).

Parses a single text line from the current input offset (which may not be at the start of the line). Fails for blank lines. Does not include the eol character(s).

Attributes

lazy val ws: Characters[String]

Parses horizontal whitespace (space and tab). Always succeeds, consuming all whitespace found.

Parses horizontal whitespace (space and tab). Always succeeds, consuming all whitespace found.

Attributes

val wsEol: Parser[Unit]

Parses any number of whitespace characters followed by a newline character.

Parses any number of whitespace characters followed by a newline character.

Attributes

Implicits

Inherited implicits

final implicit def TryOps[A](t: Try[A]): TryOps[A]

Provides additional methods to Try via implicit conversion.

Provides additional methods to Try via implicit conversion.

Attributes

Inherited from:
Parsers
Generated with