Results for “Std.Text.Parse.Problem”

Use module:Std.List, kind:fn, or is:exact. Put a Pudu type after ::.

• Std.Text.Parse.Problem

  What a parser wanted where it stopped.

  type · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.anyCharacterfn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Any one character at all.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.blanksfn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  Space and tab, but never a line ending.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.characterChar -> fn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One particular character.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.digitfn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One ASCII decimal digit.

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

  The end of the input, consuming nothing.

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

  A problem written for a person to read.

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

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

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.hexDigitfn(Std.Text.Parse.Input) -> Result[(Int, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One hexadecimal digit's value.

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

  A whole hexadecimal number, at least one digit.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.letterfn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One ASCII letter.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.lineEndfn(Std.Text.Parse.Input) -> Result[((), Std.Text.Parse.Input), Std.Text.Parse.Problem]

  A line ending, or the end of the input.

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

  A particular piece of text.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.newlinefn(Std.Text.Parse.Input) -> Result[(Str, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One line ending, however the file writes it.

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

  One character not in a set.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.oneOfStr -> fn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One character from a set.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.spacefn(Std.Text.Parse.Input) -> Result[(Char, Std.Text.Parse.Input), Std.Text.Parse.Problem]

  One space, tab, carriage return, or newline.

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

  Nought or more whitespace, discarded.

  fn · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse
• Std.Text.Parse.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 · Std.Text.Parse