Trait

laika.parse.markdown

InlineParsers

Related Doc: package markdown

Permalink

trait InlineParsers extends parse.InlineParsers

Provides all inline parsers for Markdown text except for those dealing with verbatim HTML markup which this library treats as an optional feature that has to be explicitly mixed in.

Inline parsers deal with markup within a block of text, such as a link or emphasized text. They are used in the second phase of parsing, after the block parsers have cut the document into a (potentially nested) block structure.

Self Type
InlineParsers
Linear Supertypes
parse.InlineParsers, MarkupParsers, BaseParsers, RegexParsers, Parsers, AnyRef, Any
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. InlineParsers
  2. InlineParsers
  3. MarkupParsers
  4. BaseParsers
  5. RegexParsers
  6. Parsers
  7. AnyRef
  8. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type Elem = Char

    Permalink
    Definition Classes
    RegexParsers → Parsers
  2. case class Error extends NoSuccess with Product with Serializable

    Permalink
    Definition Classes
    Parsers
  3. case class Failure extends NoSuccess with Product with Serializable

    Permalink
    Definition Classes
    Parsers
  4. type Input = Reader[Elem]

    Permalink
    Definition Classes
    Parsers
  5. class MarkupParserException extends RuntimeException

    Permalink

    Exception thrown when parsing a text markup document or fragment fails.

    Exception thrown when parsing a text markup document or fragment fails. This can only happen due to a bug in this library, as the behaviour of the parser is to treat all unknown or malformed markup as regular text and always succeed. The result property holds the NoSuccess instance that caused the failure.

    Definition Classes
    MarkupParsers
  6. sealed abstract class NoSuccess extends ParseResult[Nothing]

    Permalink
    Definition Classes
    Parsers
  7. trait OnceParser[+T] extends Parser[T]

    Permalink
    Definition Classes
    Parsers
  8. sealed abstract class ParseResult[+T] extends AnyRef

    Permalink
    Definition Classes
    Parsers
  9. abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

    Permalink
    Definition Classes
    Parsers
  10. implicit class ParserOps[A] extends AnyRef

    Permalink

    Provides additional combinator methods to parsers via implicit conversion.

    Provides additional combinator methods to parsers via implicit conversion.

    Definition Classes
    BaseParsers
  11. trait ResultBuilder[Elem, +To] extends AnyRef

    Permalink

    Abstracts the internal process of building up the result of an inline parser.

    Abstracts the internal process of building up the result of an inline parser. Since some inline parser produce a tree of nested spans whereas others may only produce a text result, they often require the same logic in how they deal with nested constructs.

    Definition Classes
    InlineParsers
  12. class SpanBuilder extends ResultBuilder[Span, List[Span]]

    Permalink

    ResultBuilder that produces a list of spans.

    ResultBuilder that produces a list of spans.

    Definition Classes
    InlineParsers
  13. case class Success[+T] extends ParseResult[T] with Product with Serializable

    Permalink
    Definition Classes
    Parsers
  14. class TextBuilder extends ResultBuilder[String, String]

    Permalink

    ResultBuilder that produces a String.

    ResultBuilder that produces a String.

    Definition Classes
    InlineParsers
  15. class TextParser extends Parser[String]

    Permalink

    API for specifying further constraints on the parsers provided by this base trait.

    API for specifying further constraints on the parsers provided by this base trait.

    For reading 3 or more '*' or '+'characters for example the constraint could be specified as follows:

    anyOf('*','+') min 3
    Definition Classes
    MarkupParsers
  16. implicit class TryOps[A] extends AnyRef

    Permalink

    Provides additional methods to Try via implicit conversion.

    Provides additional methods to Try via implicit conversion.

    Definition Classes
    BaseParsers
  17. case class ~[+a, +b] extends Product with Serializable

    Permalink
    Definition Classes
    Parsers

Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. object NoSuccess

    Permalink
    Definition Classes
    Parsers
  5. def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

    Permalink
    Definition Classes
    Parsers
  6. def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  7. def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

    Permalink
    Definition Classes
    Parsers
  8. def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

    Permalink
    Definition Classes
    Parsers
  9. implicit def accept(e: Elem): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  10. def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  11. def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

    Permalink
    Definition Classes
    Parsers
  12. def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

    Permalink
    Definition Classes
    Parsers
  13. val any: TextParser

    Permalink

    Consumes any kind of input, always succeeds.

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

    Definition Classes
    MarkupParsers
  14. def anyBut(chars: Char*): TextParser

    Permalink

    Consumes any number of consecutive characters that are not one of the specified characters.

    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.

    Definition Classes
    MarkupParsers
  15. def anyIn(ranges: Traversable[Char]*): TextParser

    Permalink

    Consumes any number of consecutive characters that are in one of the specified character ranges.

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

    Definition Classes
    MarkupParsers
  16. def anyOf(chars: Char*): TextParser

    Permalink

    Consumes any number of consecutive occurrences of the specified characters.

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

    Definition Classes
    MarkupParsers
  17. def anyUntil(until: ⇒ Parser[Any]): TextParser

    Permalink

    Consumes any number of characters for which the specified parser fails on the corresponding offset.

    Consumes any number of characters for which the specified parser fails on the corresponding offset. This parser fails if the end of input is reached without the specified parser ever succeeding or if the parser causes an Error result instead of a plain Failure or Success. Further constraints like minimum or maximum number of required matching characters can be specified through the API of the returned TextParser instance.

    Definition Classes
    MarkupParsers
  18. def anyUntil(chars: Char*): TextParser

    Permalink

    Consumes any number of consecutive characters that are not one of the specified characters.

    Consumes any number of consecutive characters that are not one of the specified characters.

    This parser is identical to the anyBut parser except for two differences: this parser fails if it reaches the end of the input without seeing any of the specified characters and it also consumes this final character, without adding it to the result. This parser is usually used when a construct like a span enclosed between two characters needs to be parsed.

    Definition Classes
    MarkupParsers
  19. def anyWhile(p: (Char) ⇒ Boolean): TextParser

    Permalink

    Consumes any number of consecutive characters which satisfy the specified predicate.

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

    Definition Classes
    MarkupParsers
  20. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  21. val atStart: Parser[Unit]

    Permalink

    Succeeds at the start of the input.

    Succeeds at the start of the input.

    Definition Classes
    MarkupParsers
  22. def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  23. def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  24. def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

    Permalink
    Definition Classes
    Parsers
  25. implicit def charToTraversalble(char: Char): Traversable[Char]

    Permalink

    Implicit conversion that allows to pass a single character to the range-based anyIn parser.

    Implicit conversion that allows to pass a single character to the range-based anyIn parser.

    Definition Classes
    MarkupParsers
  26. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  27. def commit[T](p: ⇒ Parser[T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  28. def elem(e: Elem): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  29. def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

    Permalink
    Definition Classes
    Parsers
  30. def em(char: Char): Parser[Emphasized]

    Permalink

    Parses a span of emphasized text enclosed by one occurrence of the specified character.

  31. def enclosedByDoubleChar(char: Char): Parser[List[Span]]

    Permalink

    Parses a span enclosed by two consecutive occurrences of the specified character.

    Parses a span enclosed by two consecutive occurrences of the specified character. Recursively parses nested spans, too.

  32. def enclosedBySingleChar(char: Char): Parser[List[Span]]

    Permalink

    Parses a span enclosed by a single occurrence of the specified character.

    Parses a span enclosed by a single occurrence of the specified character. Recursively parses nested spans, too.

  33. def eof: Parser[String]

    Permalink

    Succeeds at the end of the input.

    Succeeds at the end of the input.

    Definition Classes
    MarkupParsers
  34. def eol: Parser[String]

    Permalink

    Succeeds at the end of a line, including the end of the input.

    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.

    Definition Classes
    MarkupParsers
  35. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  36. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  37. def err(msg: String): Parser[Nothing]

    Permalink
    Definition Classes
    Parsers
  38. lazy val escapedChar: TextParser

    Permalink

    Parses a single escaped character, only recognizing the characters the Markdown syntax document specifies as escapable.

    Parses a single escaped character, only recognizing the characters the Markdown syntax document specifies as escapable.

    Note: escaping > is not mandated by the official syntax description, but by the official test suite.

    Definition Classes
    InlineParsersInlineParsers
  39. def escapedText(p: TextParser): Parser[String]

    Permalink

    Adds support for escape sequences to the specified text parser.

    Adds support for escape sequences to the specified text parser.

    p

    the parser to add support for escape sequences to

    returns

    a parser for a text span that supports escape sequences

    Definition Classes
    InlineParsers
  40. def escapedUntil(char: Char*): Parser[String]

    Permalink

    Parses a span of text until one of the specified characters is seen (unless it is escaped), while also processing escaped characters, but no other nested spans.

    Parses a span of text until one of the specified characters is seen (unless it is escaped), while also processing escaped characters, but no other nested spans. The final character is not included in the result.

    char

    the character that signals the end of the text span

    returns

    a parser for a text span that supports escape sequences

    Definition Classes
    InlineParsers
  41. def failure(msg: String): Parser[Nothing]

    Permalink
    Definition Classes
    Parsers
  42. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  43. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  44. def guard[T](p: ⇒ Parser[T]): Parser[T]

    Permalink
    Definition Classes
    Parsers
  45. def handleWhiteSpace(source: CharSequence, offset: Int): Int

    Permalink
    Attributes
    protected
    Definition Classes
    RegexParsers
  46. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  47. def image: Parser[Span]

    Permalink

    Parses an inline image.

    Parses an inline image. Recognizes both, an inline image ![text](url) and an image reference ![text][id].

  48. def inline[Elem, To](text: ⇒ TextParser, nested: ⇒ Map[Char, Parser[Elem]], resultBuilder: ⇒ ResultBuilder[Elem, To]): Parser[To]

    Permalink

    Generic base parser that parses inline elements based on the specified helper parsers.

    Generic base parser that parses inline elements based on the specified helper parsers. Usually not used directly by parser implementations, this is the base parser the other inline parsers of this trait delegate to.

    Elem

    the element type produced by a single parser for a nested span

    To

    the type of the result this parser produces

    nested

    a mapping from the start character of a span to the corresponding parser for nested span elements

    resultBuilder

    responsible for building the final result of this parser based on the results of the helper parsers

    returns

    the resulting parser

    Definition Classes
    InlineParsers
  49. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  50. def lineBreak: Parser[LineBreak]

    Permalink

    Parses an explicit hard line break.

  51. def link: Parser[Span]

    Permalink

    Parses a link, including nested spans in the link text.

    Parses a link, including nested spans in the link text. Recognizes both, an inline link [text](url) and a link reference [text][id].

  52. def linkTarget: Parser[ExternalLinkDefinition]

    Permalink

    Parses a link definition in the form [id]: <url> "title".

    Parses a link definition in the form [id]: <url> "title". The title is optional as well as the quotes around it and the angle brackets around the url.

  53. implicit def literal(s: String): Parser[String]

    Permalink
    Definition Classes
    RegexParsers
  54. def literalEnclosedByDoubleChar: Parser[Literal]

    Permalink

    Parses a literal span enclosed by double backticks.

    Parses a literal span enclosed by double backticks. Does neither parse nested spans nor Markdown escapes.

  55. def literalEnclosedBySingleChar: Parser[Literal]

    Permalink

    Parses a literal span enclosed by a single backtick.

    Parses a literal span enclosed by a single backtick. Does neither parse nested spans nor Markdown escapes.

  56. def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

    Permalink
    Definition Classes
    Parsers
  57. def lookBehind[T](offset: Int, parser: ⇒ Parser[T]): Parser[T]

    Permalink

    Applies the specified parser at the specified offset behind the current position.

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

    Definition Classes
    BaseParsers
  58. def mkList[T]: (~[T, List[T]]) ⇒ List[T]

    Permalink
    Definition Classes
    Parsers
  59. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  60. def not[T](p: ⇒ Parser[T]): Parser[Unit]

    Permalink
    Definition Classes
    Parsers
  61. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  62. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  63. def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

    Permalink
    Definition Classes
    Parsers
  64. def optimizedCharLookup(chars: Char*): (Char) ⇒ Boolean

    Permalink

    Returns an optimized, Array-based lookup function for the specified characters.

    Returns an optimized, Array-based lookup function for the specified characters.

    Attributes
    protected
    Definition Classes
    MarkupParsers
  65. def optimizedRangeLookup(ranges: Traversable[Char]*): (Char) ⇒ Boolean

    Permalink

    Returns an optimized, Array-based lookup function for the specified ranges of characters.

    Returns an optimized, Array-based lookup function for the specified ranges of characters.

    Attributes
    protected
    Definition Classes
    MarkupParsers
  66. def parse[T](p: Parser[T], in: Reader): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  67. def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  68. def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  69. def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  70. def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  71. def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

    Permalink
    Definition Classes
    RegexParsers
  72. def parseInline(source: String): List[Span]

    Permalink

    Fully parses the input string and produces a list of spans, using the default span parsers returned by the spanParsers method.

    Fully parses the input string and produces a list of spans, using the default span parsers returned by the spanParsers method.

    This function is expected to always succeed, errors would be considered a bug of this library, as the parsers treat all unknown or malformed markup as regular text. Some parsers might additionally insert system message elements in case of markup errors.

    source

    the input to parse

    returns

    the result of the parser in form of a list of spans

    Definition Classes
    InlineParsers
  73. def parseInline(source: String, spanParsers: Map[Char, Parser[Span]]): List[Span]

    Permalink

    Fully parses the input string and produces a list of spans.

    Fully parses the input string and produces a list of spans.

    This function is expected to always succeed, errors would be considered a bug of this library, as the parsers treat all unknown or malformed markup as regular text. Some parsers might additionally insert system message elements in case of markup errors.

    source

    the input to parse

    spanParsers

    a mapping from the start character of a span to the corresponding parser

    returns

    the result of the parser in form of a list of spans

    Definition Classes
    InlineParsers
  74. def parseMarkup[T](parser: Parser[T], reader: Reader[Char]): T

    Permalink

    Fully parses the input from the specified reader and returns the result.

    Fully parses the input from the specified reader and returns the result. This function is expected to always succeed, errors would be considered a bug in this library, as the parsers treat all unknown or malformed markup as regular text.

    Definition Classes
    MarkupParsers
  75. def parseMarkup[T](parser: Parser[T], source: String): T

    Permalink

    Fully parses the specified input string and returns the result.

    Fully parses the specified input string and returns the result. This function is expected to always succeed, errors would be considered a bug in this library, as the parsers treat all unknown or malformed markup as regular text.

    Definition Classes
    MarkupParsers
  76. def phrase[T](p: Parser[T]): Parser[T]

    Permalink
    Definition Classes
    RegexParsers → Parsers
  77. def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

    Permalink
    Definition Classes
    RegexParsers → Parsers
  78. def prepareSpanParsers: Map[Char, Parser[Span]]

    Permalink

    Creates a new mapping from the start character of an inline span to the corresponding parser.

    Creates a new mapping from the start character of an inline span to the corresponding parser. May be overridden by subtraits.

    Attributes
    protected
    Definition Classes
    InlineParsersInlineParsers
  79. val refName: Parser[String]

    Permalink

    Parses a simple reference name that only allows alphanumerical characters and the punctuation characters -, _, ., :, +.

    Parses a simple reference name that only allows alphanumerical characters and the punctuation characters -, _, ., :, +.

    Definition Classes
    MarkupParsers
  80. implicit def regex(r: Regex): Parser[String]

    Permalink
    Definition Classes
    RegexParsers
  81. def rep[T](first: ⇒ Parser[T], next: (T) ⇒ Parser[T]): Parser[List[T]]

    Permalink

    A parser generator for repetitions where all subsequent parsers after the first depend on the result of the previous.

    A parser generator for repetitions where all subsequent parsers after the first depend on the result of the previous.

    first

    the parser to use for the first piece of input

    next

    a function that determines the next parser based on the result of the previous

    Definition Classes
    BaseParsers
  82. def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  83. def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
    Annotations
    @migration
    Migration

    (Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.

  84. def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  85. def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  86. def repMax[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

    Permalink

    Uses the parser for at most the specified number of repetitions, always succeeds.

    Uses the parser for at most the specified number of repetitions, always succeeds. The result is the list of results from applying the parser repeatedly.

    Definition Classes
    BaseParsers
  87. def repMin[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

    Permalink

    Uses the parser for at least the specified number of repetitions or otherwise fails.

    Uses the parser for at least the specified number of repetitions or otherwise fails. Continues to apply the parser after the minimum has been reached until if fails. The result is the list of results from applying the parser repeatedly.

    Definition Classes
    BaseParsers
  88. def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  89. def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

    Permalink
    Definition Classes
    Parsers
  90. def resource(inline: (String, String, Option[String]) ⇒ Span, ref: (String, String, String) ⇒ Span): Parser[Span]

    Permalink

    Helper function that abstracts the common parser logic of links and images.

    Helper function that abstracts the common parser logic of links and images.

    inline

    factory function for creating a new inline link or image based on the text, url and optional title parameters

    ref

    factory function for creating a new link or image reference based on the text and id parameters

  91. def simpleLink: Parser[ExternalLink]

    Permalink

    Parses a simple inline link in the form of <http://someURL/>

  92. def skipWhitespace: Boolean

    Permalink
    Definition Classes
    MarkupParsers → RegexParsers
  93. def span(start: Parser[Any], end: Parser[Any]): Parser[List[Span]]

    Permalink

    Creates a parser for an inline span based on the specified parsers that represent the start and end condition.

    Creates a parser for an inline span based on the specified parsers that represent the start and end condition.

    start

    the parser that parses the beginning of the span, result will be discarded

    end

    the parser that recognizes the end of the span, result will be discarded

  94. final lazy val spanParsers: Map[Char, Parser[Span]]

    Permalink

    The mapping of markup start characters to their corresponding span parsers.

    The mapping of markup start characters to their corresponding span parsers.

    A parser mapped to a start character is not required to successfully parse the subsequent input. If it fails the character that triggered the parser invocation will be treated as normal text. The mapping is merely used as a performance optimization. The parser will be invoked with the input offset pointing to the character after the one specified as the key for the mapping.

    Definition Classes
    InlineParsers
  95. def spans(parser: ⇒ TextParser, spanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

    Permalink

    Parses a list of spans based on the specified helper parsers.

    Parses a list of spans based on the specified helper parsers.

    parser

    the parser for the text of the current span element

    returns

    the resulting parser

    Definition Classes
    InlineParsers
  96. def strong(char: Char): Parser[Strong]

    Permalink

    Parses a span of strong text enclosed by two consecutive occurrences of the specified character.

  97. def success[T](v: T): Parser[T]

    Permalink
    Definition Classes
    Parsers
  98. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  99. def text(parser: ⇒ TextParser, nested: ⇒ Map[Char, Parser[String]]): Parser[String]

    Permalink

    Parses text based on the specified helper parsers.

    Parses text based on the specified helper parsers.

    parser

    the parser for the text of the current element

    nested

    a mapping from the start character of a span to the corresponding parser for nested span elements

    returns

    the resulting parser

    Definition Classes
    InlineParsers
  100. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  101. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  102. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  103. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  104. val whiteSpace: Regex

    Permalink
    Attributes
    protected
    Definition Classes
    RegexParsers
  105. def ws: TextParser

    Permalink

    Parses horizontal whitespace (space and tab).

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

    Definition Classes
    MarkupParsers

Inherited from parse.InlineParsers

Inherited from MarkupParsers

Inherited from BaseParsers

Inherited from RegexParsers

Inherited from Parsers

Inherited from AnyRef

Inherited from Any

Ungrouped