refactor: drop last parameter input

refactor: drop last parameter `input`

Author: jaschdoc

src/Parser.flix

@@ -23,168 +23,193 @@ pub type alias Parser[a, b] = Input[b] -> ParseResult[a, b]
 namespace Parser {
 
     ///
-    /// Returns a non-empty `ParseResult` with value `b`
+    /// Returns a parser that always succeeds with value `b`
     /// regardless of input.
     ///
-    pub def succeed(a: a, input: Input[b]): ParseResult[a, b] =
-        (a, input) :: Nil
+    pub def succeed(a: a): Parser[a, b] =
+        inp -> (a, inp) :: Nil
 
     ///
-    /// Returns an empty `ParseResult` regardless of input.
+    /// Returns a parser that always fails regardless of input.
     ///
     /// Equivalent to the empty string ϵ.
     ///
     pub def fail(_: Input[b]): ParseResult[a, b] =
         Nil
 
     ///
-    /// Returns a non-empty `ParseResult` if the input is non-empty
-    /// and the first element satisfies the predicate `p`.
-    /// Returns an empty `ParseResult` otherwise.
+    /// Returns a parser that succeeds with value `x`
+    /// if the input is non-empty and the first
+    /// element `x` of the input satisfies
+    /// the predicate `p(x)`.
     ///
-    pub def satisfy(p: a -> Bool, input: Input[a]): ParseResult[a, a] = match input {
-        case Nil             => fail(input)
-        case x :: xs if p(x) => succeed(x, xs)
-        case _ :: xs         => fail(xs)
-    }
+    /// The parser fails otherwise.
+    ///
+    pub def satisfy(p: a -> Bool): Parser[a, a] =
+        inp -> match inp {
+            case Nil             => fail(inp)
+            case x :: xs if p(x) => succeed(x, xs)
+            case _ :: xs         => fail(xs)
+        }
 
     ///
-    /// Returns a non-empty `ParseResult` if the first element of the input
-    /// is equal to `a`.
-    /// Returns an empty ParseReult otherwise.
+    /// Returns a parser that succeeds with value `a`
+    /// if the first element of the input is equal to `a`.
+    ///
+    /// The parser fails otherwise.
     ///
-    pub def literal(a: a, input: Input[a]): ParseResult[a, a] with Eq[a] =
-        satisfy(Eq.eq(a) , input)
+    pub def literal(a: a): Parser[a, a] with Eq[a] =
+        satisfy(Eq.eq(a))
 
     ///
-    /// Returns the result of parser `p1` applied to `input`
-    /// followed by the result of parser `p2` applied to `input`.
+    /// Returns a parser that recognizes the alternation
+    /// of `p1` and `p2` (i.e. it recognizes both `p1` and `p2`).
     ///
-    pub def otherwise(p1: Parser[a, b], p2: Parser[a, b], input: Input[b]): ParseResult[a, b] =
-        p1(input) ::: p2(input)
+    /// Equivalent to `p1` | `p2`.
+    ///
+    pub def otherwise(p1: Parser[a, b], p2: Parser[a, b]): Parser[a, b] =
+        inp -> p1(inp) ::: p2(inp)
 
     ///
-    /// Returns the `ParseResult` of sequencing `p1`, `p2`, i.e.
-    /// `p1` is applied to the input and `p2` is applied to the
-    /// input that `p1` did not consume.
+    /// Returns a parser that recognizes the concatenation of
+    /// `p1` and `p2`.
     ///
-    /// Equivalent to `AB` where `A` and `B` are non-terminals.
+    /// Equivalent to `p1p2`.
     ///
-    pub def then(p1: Parser[a, b], p2: Parser[c, b], input: Input[b]): ParseResult[(a, c), b] =
-        for (
-            (x1, rest1) <- p1(input);
-            (x2, rest2) <- p2(rest1)
-        ) yield ((x1, x2), rest2)
+    pub def then(p1: Parser[a, b], p2: Parser[c, b]): Parser[(a, c), b] =
+        inp ->
+            for (
+                (x1, rest1) <- p1(inp);
+                (x2, rest2) <- p2(rest1)
+            ) yield ((x1, x2), rest2)
 
     ///
-    /// Returns a `ParseResult` that recognizes the concatenation of `p1` and `p2`
-    /// but discards the result of `p1`.
+    /// Returns a parser that recognizes the concatenation of
+    /// `p1` and `p2` but discards the result of `p1`.
     ///
-    pub def thenIgnoringLeft(p1: Parser[a, b], p2: Parser[c, b], input: Input[b]): ParseResult[c, b] =
-        input |> ((p1 `then` p2) `using` snd)
+    pub def thenIgnoringLeft(p1: Parser[a, b], p2: Parser[c, b]): Parser[c, b] =
+        (p1 `then` p2) `using` snd
 
     ///
-    /// Returns a `ParseResult` that recognizes the concatenation of `p1` and `p2`
-    /// but discards the result of `p2`.
+    /// Returns a parser that recognizes the concatenation of
+    /// `p1` and `p2` but discards the result of `p2`.
     ///
-    pub def thenIgnoringRight(p1: Parser[a, b], p2: Parser[c, b], input: Input[b]): ParseResult[a, b] =
-        input |> ((p1 `then` p2) `using` fst)
+    pub def thenIgnoringRight(p1: Parser[a, b], p2: Parser[c, b]): Parser[a, b] =
+        (p1 `then` p2) `using` fst
 
     ///
-    /// Returns the result of applying `f` to every element of
-    /// the `ParseResult` of `p` on `input`.
+    /// Returns a parser that applies `f` to all recognized
+    /// values of `p`.
+    ///
+    /// Useful for producing AST nodes.
     ///
-    pub def using(p: Parser[a, b], f: a -> c, input: Input[b]): ParseResult[c, b] =
-        for (
-            (x, rest) <- p(input)
-        ) yield (f(x), rest)
+    pub def using(p: Parser[a, b], f: a -> c): Parser[c, b] =
+        inp ->
+            for (
+                (x, rest) <- p(inp)
+            ) yield (f(x), rest)
 
     ///
-    /// Returns zero or more results of the parser `p`.
+    /// Returns a parser that recognizes zero or more repetitions
+    /// of `p`.
     ///
     /// Note that it always succeeds, so the result will always
-    /// be non-empty, but the rest of the input may be `Nil`, along
-    /// with the result. I.e. both the value of `List[a]` may be `Nil`
-    /// and `b` may be `Nil`.
+    /// be non-empty, but the rest of the inp may be empty as well as
+    /// the result.
+    /// I.e. both the recognized value of may be empty (but still exist) and
+    /// the unconsumed may be empty (but still exist).
     ///
-    /// Equivalent to `A*`.
+    /// Equivalent to `p*`.
     ///
-    pub def many(p: Parser[a, b], input: Input[b]): ParseResult[List[a], b] =
-        let p1 = (p `then` many(p)) `using` cons;
-        otherwise(p1, succeed(Nil), input)
+    pub def many(p: Parser[a, b]): Parser[List[a], b] =
+        inp -> inp // Wrap in lambda so the recursive call does not immediately happen
+            |> (((p `then` many(p)) `using` cons) `otherwise` succeed(Nil))
 
     ///
-    /// Returns one or more results of the parser `p`.
+    /// Returns a parser that recognizes one or more repetitions
+    /// of `p`.
     ///
     /// Note that unlike `many`, this parser may fail, i.e.
-    /// return 0 results.
+    /// not recognize anything.
     ///
-    /// Equivalent to `A+`.
+    /// Equivalent to `p+`.
     ///
-    pub def some(p: Parser[a, b], input: Input[b]): ParseResult[List[a], b] =
-        ((p `then` many(p)) `using` cons)(input)
+    pub def some(p: Parser[a, b]): Parser[List[a], b] =
+        (p `then` many(p)) `using` cons
 
     ///
-    /// Returns one or more `ParseResults` recognizing numbers.
+    /// Returns a parser that recognizes numbers (consecutive integer characters).
+    ///
+    /// All possible parses of the number will be recognized.
+    ///
+    /// E.g. `123` is recognized as `123, 12, 1`.
+    ///
     /// The longest match will be the first result.
     ///
-    pub def number(input: Input[Char]): ParseResult[List[Char], Char] =
+    pub def number(inp: Input[Char]): ParseResult[List[Char], Char] =
         let digit = c -> '0' <= c and c <= '9';
-        input |> some(satisfy(digit))
+        inp |> some(satisfy(digit))
 
     ///
-    /// Returns one or more `ParseResults` recognizing consecutive chars.
+    /// Returns a parser that recognizes words
+    /// (consectutive non-integer, non-whitespace characters).
+    ///
+    /// All possible parses of the word will be recognized.
+    ///
+    /// E.g. `hello` is recognized as `hello, hell, hel, he, h`.
+    ///
     /// The longest match will be the first result.
     ///
-    pub def word(input: Input[Char]): ParseResult[List[Char], Char] =
+    pub def word(inp: Input[Char]): ParseResult[List[Char], Char] =
         let lowercase = c -> 'a' <= c and c <= 'z';
         let uppercase = c -> 'A' <= c and c <= 'Z';
         let letter = c -> lowercase(c) or uppercase(c);
-        input |> some(satisfy(letter))
+        inp |> some(satisfy(letter))
 
     ///
-    /// Returns a `ParseResult` that recognizes the sequence `lit`.
+    /// Returns a parser that recognizes the sequence `lit`.
+    ///
     /// This is generalization of `literal`.
     ///
-    pub def literalSequence(lit: List[a], input: Input[a]): ParseResult[List[a], a] with Eq[a] =
-        let p = match lit {
-            case Nil     => succeed(Nil)
-            case x :: xs => (literal(x) `then` (literalSequence(xs))) `using` cons
-        };
-        p(input)
+    pub def literalSequence(lit: List[a]): Parser[List[a], a] with Eq[a] =
+        inp -> // Wrap in lambda so the recursive call does not immediately happen
+            match lit {
+                case Nil     => succeed(Nil)
+                case x :: xs => (literal(x) `then` (literalSequence(xs))) `using` cons
+            }(inp)
 
     ///
-    /// Returns a `ParseResult` containing the value `c` if `p` is succesful.
+    /// Returns parser that returns the the value `c` if `p` is succesful.
     ///
-    pub def return(p: Parser[a, b], c: c, input: Input[b]): ParseResult[c, b] =
+    pub def return(p: Parser[a, b], c: c): Parser[c, b] =
         let const = (x, _) -> x;
-        (p `using` (const(c)))(input)
+        p `using` const(c)
 
     ///
-    /// Returns a `ParseResult` that recognizes the string `s`.
+    /// Returns a parser that recognizes the string `s`.
     ///
-    pub def string(s: String, input: Input[Char]): ParseResult[List[Char], Char] =
-        (String.toList >> literalSequence)(s, input)
+    pub def string(s: String): Parser[List[Char], Char] =
+        s |> (String.toList >> literalSequence)
 
     ///
-    /// Returns a `ParseResult` where white-space
-    /// has been removed on both sides of `p`.
+    /// Returns a parser that ignores whitespace on both
+    /// sides of `p`.
     ///
-    pub def nibble(p: Parser[a, Char], input: Input[Char]): ParseResult[a, Char] =
-        input |> (whitespace `thenIgnoringLeft` p `thenIgnoringRight` whitespace)
+    pub def nibble(p: Parser[a, Char]): Parser[a, Char] =
+        whitespace `thenIgnoringLeft` p `thenIgnoringRight` whitespace
 
     ///
-    /// Returns a `ParseResult` that recognizes whitespace.
+    /// Returns a parser that recognizes whitespace.
     ///
-    pub def whitespace(input: Input[Char]): ParseResult[List[Char], Char] =
+    pub def whitespace(inp: Input[Char]): ParseResult[List[Char], Char] =
         let chars = String.toList(" \t\n");
-        input |> (many(any(literal, chars)))
+        inp |> (many(any(literal, chars)))
 
     ///
-    /// Returns a `ParseResult` that recognizes any of the elements in `syms`.
+    /// Returns a parser that recognizes any of the elements in `syms`.
     ///
-    pub def any(f: a -> Parser[b, c], syms: List[a], input: Input[c]): ParseResult[b, c] =
-        input |> List.foldRight(f >> otherwise, fail, syms)
+    pub def any(f: a -> Parser[b, c], syms: List[a]): Parser[b, c] =
+        List.foldRight(f >> otherwise, fail, syms)
 
     ///
     /// Returns the string `s` as an `Input` type.