Std.Text.Parse

69 public declarations

• andThenfn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(A) -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One parser after another, the second chosen by the first's value.

  fn
• anyCharacterfn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Any one character at all.

  fn
• asTextfn(Std.Text.Parse.Input) -> Result[(Array[Char], Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The text a parser's characters spell.

  fn
• attemptfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser that consumes nothing when it fails, so `orElse` may try another.

  fn
• betweenfn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser between two others, keeping only the middle value.

  fn
• bigIntegerfn(Std.Text.Parse.Input) -> Result[(BigInt, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One or more digits as an arbitrary-precision whole number.

  fn
• blanksfn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Space and tab, but never a line ending.

  fn
• bothfn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[((A, B), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Two parsers in order, keeping both values.

  fn
• characterChar -> fn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One particular character.

  fn
• choice&Array[fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]] -> Str -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The first parser that succeeds.

  fn
• countInt -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Exactly this many of a parser, and a problem if the input runs out first.

  fn
• digitfn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One ASCII decimal digit.

  fn
• endOfInputfn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The end of the input, consuming nothing.

  fn
• explain&Std.Text.Parse.Problem -> Str

  A problem written for a person to read.

  fn
• explainIn&Std.Text.Parse.Problem -> Str -> Str

  A problem written for a person reading a file, with the line and column.

  fn
• failStr -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser that consumes nothing and always fails.

  fn
• hexadecimalfn(Std.Text.Parse.Input) -> Result[(Int, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A whole hexadecimal number, at least one digit.

  fn
• hexDigitfn(Std.Text.Parse.Input) -> Result[(Int, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One hexadecimal digit's value.

  fn
• identifierfn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A run of letters, digits, and underscores beginning with a letter.

  fn
• Input

  What a parser has not read yet, and how far it has come.

  type
• integerfn(Std.Text.Parse.Input) -> Result[(Int, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One or more digits as an `Int`, the common case of `integerIn`.

  fn
• integerInN -> fn(Std.Text.Parse.Input) -> Result[(N, Std.Text.Parse.Input), Std.Text.Parse.Problem] where N: Integer

  A whole number counted in the caller's own integer type.

  fn
• keepFirstfn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Two parsers in order, keeping the first's value.

  fn
• keepSecondfn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Two parsers in order, keeping the second's value.

  fn
• labelStr -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Say what a parser wanted, in the reader's words rather than the grammar's.

  fn
• lazyfn() -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser built only when it is run.

  fn
• letterfn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One ASCII letter.

  fn
• linefn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One whole line, without its ending, and the ending consumed.

  fn
• lineAndColumnStr -> Int -> (Int, Int)

  Where a position falls in the source, counted from one as a reader counts.

  fn
• lineEndfn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A line ending, or the end of the input.

  fn
• literalStr -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A particular piece of text.

  fn
• lookAheadfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Succeed exactly where the parser would, consuming nothing.

  fn
• manyfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Nought or more, until the parser stops.

  fn
• manyTillfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(E, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Repeat a parser until the end parser succeeds, keeping what came before.

  fn
• mapfn(Std.Text.Parse.Input) -> Result[(A, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(A) -> B -> fn(Std.Text.Parse.Input) -> Result[(B, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser's value transformed.

  fn
• newlinefn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One line ending, however the file writes it.

  fn
• noneOfStr -> fn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One character not in a set.

  fn
• notFollowedByStr -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Succeed, consuming nothing, only where the parser would fail.

  fn
• oneOfStr -> fn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One character from a set.

  fn
• optionT -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser's value, or a fallback when it fails without consuming.

  fn
• optionalfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Option[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser's value if it succeeds, and nothing if it fails without consuming.

  fn
• orElsefn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The first parser, or the second when the first consumed nothing.

  fn
• Parser

  A parser: a function from input to a step.

  type
• partialfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> Str -> Result[(T, Int), Std.Text.Parse.Problem]

  Run a parser over text, allowing input to remain.

  fn
• Problem

  What a parser wanted where it stopped.

  type
• pureT -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser that consumes nothing and answers with a value.

  fn
• quotedfn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Text between double quotes, with the usual escapes read.

  fn
• restOfLinefn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Everything up to, but not including, the next line ending.

  fn
• runfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> Str -> Result[T, Std.Text.Parse.Problem]

  Run a parser over text, requiring it to consume all of it.

  fn
• satisfyStr -> fn(Char) -> Bool -> fn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One character the predicate accepts.

  fn
• separatedByfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(S, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Nought or more, separated by another parser.

  fn
• separatedSomefn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(S, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One or more, separated by another parser.

  fn
• sepEndByfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(S, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Items separated by, and optionally ended by, a separator.

  fn
• sepEndSomefn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(S, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The same, requiring at least one item.

  fn
• signedfn(Std.Text.Parse.Input) -> Result[(N, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(N, Std.Text.Parse.Input), Std.Text.Parse.Problem] where N: Integer

  An optional sign, applied to a number.

  fn
• skipManyfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Run a parser and keep nothing, as many times as it succeeds.

  fn
• skipSomefn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The same, requiring at least one.

  fn
• somefn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(Array[T], Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One or more.

  fn
• spacefn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One space, tab, carriage return, or newline.

  fn
• spacesfn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Nought or more whitespace, discarded.

  fn
• Step

  What one step of parsing produced: a value and what remains, or a problem.

  type
• symbolStr -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A particular piece of text, with trailing whitespace discarded.

  fn
• takeNotOfStr -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The longest run made of none of these characters, possibly none.

  fn
• takeNotOf1Str -> Str -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The same, requiring at least one character.

  fn
• takeOfStr -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The longest run made only of these characters, possibly none.

  fn
• takeOf1Str -> Str -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The same, requiring at least one character.

  fn
• takeWhilefn(Char) -> Bool -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The longest run of characters the predicate accepts, as text, possibly none.

  fn
• takeWhile1Str -> fn(Char) -> Bool -> fn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  The same, requiring at least one character.

  fn
• tokenfn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem] -> fn(Std.Text.Parse.Input) -> Result[(T, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A parser with any whitespace after it discarded, which is what a token is.

  fn