object Parser

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Parser
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. final case class Backtrack[Err, In, Result](parser: Parser[Err, In, Result]) extends Parser[Err, In, Result] with Product with Serializable
  2. final case class CaptureString[Err, Err2](parser: Parser[Err, Char, Any]) extends Parser[Err2, Char, String] with Product with Serializable
  3. final case class Fail[+Err](failure: Err) extends Parser[Err, Any, Nothing] with Product with Serializable
  4. final case class Failed[+Err](failure: ParserError[Err]) extends Parser[Err, Any, Nothing] with Product with Serializable
  5. final case class FlatMap[Err, Err2, In, In2, Result, Result2](parser: Parser[Err, In, Result], f: (Result) => Parser[Err2, In2, Result2]) extends Parser[Err2, In2, Result2] with Product with Serializable
  6. final case class Ignore[Err, Err2, In, Result, Result2](parser: Parser[Err, In, Result], to: Result2) extends Parser[Err2, In, Result2] with Product with Serializable
  7. final case class Lazy[+Err, -In, +Result](inner: () => Parser[Err, In, Result]) extends Parser[Err, In, Result] with Product with Serializable
  8. final case class MapError[Err, Err2, In, Result](parser: Parser[Err, In, Result], mapParserErr: (ParserError[Err]) => ParserError[Err2]) extends Parser[Err2, In, Result] with Product with Serializable
  9. final case class Named[Err, In, Result](parser: Parser[Err, In, Result], name: String) extends Parser[Err, In, Result] with Product with Serializable
  10. final case class Not[Err, In](parser: Parser[Err, In, Any], failure: Err) extends Parser[Err, In, Unit] with Product with Serializable
  11. final case class Optional[Err, In, Result](parser: Parser[Err, In, Result]) extends Parser[Err, In, Option[Result]] with Product with Serializable
  12. final case class OrElse[Err, Err2, In, In2, Result, Result2](left: Parser[Err, In, Result], right: Parser[Err2, In2, Result2]) extends Parser[Err2, In2, Result2] with Product with Serializable
  13. final case class OrElseEither[Err, Err2, In, In2, Result, Result2](left: Parser[Err, In, Result], right: Parser[Err2, In2, Result2]) extends Parser[Err2, In2, Either[Result, Result2]] with Product with Serializable
  14. final case class ParseRegex[Err](regex: Regex, onFailure: Option[Err]) extends Parser[Err, Char, Chunk[Char]] with Product with Serializable
  15. final case class ParseRegexLastChar[Err](regex: Regex, onFailure: Option[Err]) extends Parser[Err, Char, Char] with Product with Serializable
  16. sealed trait ParserError[+Err] extends AnyRef

    Type representing a parser error

  17. final case class Repeat[Err, In, Result](parser: Parser[Err, In, Result], min: Int, max: Option[Int]) extends Parser[Err, In, Chunk[Result]] with Product with Serializable
  18. final case class SetAutoBacktrack[Err, In, Result](parser: Parser[Err, In, Result], enabled: Boolean) extends Parser[Err, In, Result] with Product with Serializable
  19. final case class SkipRegex[Err](regex: Regex, onFailure: Option[Err]) extends Parser[Err, Char, Unit] with Product with Serializable
  20. final case class Succeed[+Result](value: Result) extends Parser[Nothing, Any, Result] with Product with Serializable
  21. final case class Transform[Err, Err2, In, Result, Result2](parser: Parser[Err, In, Result], to: (Result) => Result2) extends Parser[Err2, In, Result2] with Product with Serializable
  22. final case class TransformEither[Err, Err2, In, Result, Result2](parser: Parser[Err, In, Result], to: (Result) => Either[Err2, Result2]) extends Parser[Err2, In, Result2] with Product with Serializable
  23. final case class Zip[Err, Err2, In, In2, Result, Result2, ZippedResult](left: Parser[Err, In, Result], right: Parser[Err2, In2, Result2], zip: (Result, Result2) => ZippedResult) extends Parser[Err2, In2, ZippedResult] with Product with Serializable
  24. final case class ZipLeft[Err, Err2, In, In2, Result](left: Parser[Err, In, Result], right: Parser[Err2, In2, Any]) extends Parser[Err2, In2, Result] with Product with Serializable
  25. final case class ZipRight[Err, Err2, In, In2, Result, Result2](left: Parser[Err, In, Result], right: Parser[Err2, In2, Result2]) extends Parser[Err2, In2, Result2] with Product with Serializable

Value Members

  1. lazy val alphaNumeric: Parser[String, Char, Char]

    Parser of a single alpha-numeric character

  2. val anyChar: Parser[Nothing, Char, Char]

    Parser that consumes a single character and returns it

  3. val anyString: Parser[Nothing, Char, String]

    Parser that consumes the whole input and captures it as a string

  4. def char[Err](value: Char, failure: Err): Parser[Err, Char, Unit]

    Parser that consumes the exact character 'value' or fails with 'failure' if it did not match, and results in the unit value

  5. def char(value: Char): Parser[String, Char, Unit]

    Parser that consumes the exact character 'value' or fails if it did not match, and results in the unit value.

  6. def charIn(chars: Char*): Parser[String, Char, Char]

    Parser that consumes a single character and succeeds with it if it is one of the provided 'chars'

  7. def charNotIn(chars: Char*): Parser[String, Char, Char]

    Parser that consumes a single character and succeeds with it if it is NOT one of the provided 'chars'

  8. lazy val digit: Parser[String, Char, Char]

    Parser of a single digit

  9. lazy val end: Parser[Nothing, Any, Unit]

    Parser that only succeeds if the input stream has been consumed fully.

    Parser that only succeeds if the input stream has been consumed fully.

    This can be used to require that a parser consumes the full input.

  10. def fail[Err](failure: Err): Parser[Err, Any, Nothing]

    Parser that always fails with 'failure'

  11. lazy val ignoreRest: Parser[Nothing, Char, Unit]

    Parser that consumes and discards all the remaining input

  12. lazy val index: Parser[Nothing, Any, Int]

    Parser that results in the current input stream position

  13. lazy val letter: Parser[String, Char, Char]

    Parser of a single letter

  14. def notChar[Err](value: Char, failure: Err): Parser[Err, Char, Char]

    Parser that consumes a single character, fails with 'failure' if it is 'value', otherwise results with it

  15. def notChar(value: Char): Parser[String, Char, Char]

    Parser that consumes a single character, fails if it is 'value', otherwise results with it

  16. def regex[Err](regex: Regex, failure: Err): ParseRegex[Err]

    Parser that executes a regular expression on the input and results in the chunk of the parsed characters, or fails with 'failure'.

  17. def regexChar[Err](regex: Regex, failure: Err): ParseRegexLastChar[Err]

    Parser that executes a regular expression on the input and results in the last parsed character, or fails with 'failure'.

    Parser that executes a regular expression on the input and results in the last parsed character, or fails with 'failure'. Useful for regexes that are known to parse a single character.

  18. def regexDiscard[Err](regex: Regex, failure: Err): Parser[Err, Char, Unit]

    Parser that executes a regular expression on the input but discards its result, and fails with 'failure' if the regex fails

  19. def string[Result](str: String, value: Result): Parser[String, Char, Result]

    Parser that requires a given string 'str' and in case it could read it, results in 'value'

  20. def succeed[Result](value: Result): Parser[Nothing, Any, Result]

    Parser that does not consume any input and succeeds with 'value'

  21. lazy val unit: Parser[Nothing, Any, Unit]

    Parser that does not consume the input and results in unit

  22. def unsafeRegex(regex: Regex): ParseRegex[Nothing]

    Parser that executes a regular expression on the input and results in the chunk of the parsed characters.

    Parser that executes a regular expression on the input and results in the chunk of the parsed characters. The regex is supposed to never fail.

  23. def unsafeRegexChar[E](regex: Regex): ParseRegexLastChar[E]

    Parser that executes a regular expression on the input and results in the last parsed character.

    Parser that executes a regular expression on the input and results in the last parsed character. The regex is supposed to never fail. Useful for regexes that are known to parse a single character.

  24. def unsafeRegexDiscard(regex: Regex): Parser[Nothing, Char, Unit]

    Parser that executes a regular expression on the input but discards its result.

    Parser that executes a regular expression on the input but discards its result. The regex is supposed to never fail.

  25. lazy val whitespace: Parser[String, Char, Char]

    Parser of a single whitespace character

  26. case object End extends Parser[Nothing, Any, Unit] with Product with Serializable
  27. case object Index extends Parser[Nothing, Any, Int] with Product with Serializable
  28. object ParserError