refactor: streamline parser function calls and update result handling

Author: dsiu

README.md

@@ -93,7 +93,7 @@ Success example:
 
 // Pipe operator |>
 
-P.anyDigit |> P.runParser("1") // Belt.Result.Ok("1")
+P.anyDigit |> P.runParser("1") // Result.Ok("1")
 
 // Or normal function application
 
@@ -103,7 +103,7 @@ P.runParser("1", P.anyDigit)
 Failure example:
 
 ```reason
-P.anyDigit |> P.runParser("!") // Belt.Result.Error(ParseError("Expected a digit"))
+P.anyDigit |> P.runParser("!") // Result.Error(ParseError("Expected a digit"))
 ```
 
 In the event of a failed parse, parsers will (in most cases) back-track so that an alternative
@@ -119,7 +119,7 @@ A `RelueParse.Parser` is a `functor`, so we can map a pure function over the par
 
 ```reason
 // Warning: int_of_string is unsafe (can throw) - this is just an example
-P.anyDigit |> P.map(int_of_string) |> P.runParser("1") // Belt.Result.Ok(1)
+P.anyDigit |> P.map(int_of_string) |> P.runParser("1") // Result.Ok(1)
 
 // <$> map operator version.  <$> is traditionally "function on the left"
 int_of_string <$> P.anyDigit |> P.runParser("1");
@@ -154,31 +154,31 @@ together using a variety of techniques.
 
 ```reason
 // Combine two parsers into a tuple of the results (assuming all succeed)
-P.tuple2(P.anyDigit, P.anyDigit) |> P.runParser("12") // Belt.Result.Ok(("1", "2"))
+P.tuple2(P.anyDigit, P.anyDigit) |> P.runParser("12") // Result.Ok(("1", "2"))
 
 // <^> operator (operator version of tuple2)
-P.anyDigit <^> P.anyDigit |> P.runParser("12") // Belt.Result.Ok(("1", "2"))
+P.anyDigit <^> P.anyDigit |> P.runParser("12") // Result.Ok(("1", "2"))
 
 // Combine more parsers using tuple3 up to tuple5
 P.tuple3(P.anyDigit, P.anyDigit, P.anyDigit)
-|> P.runParser("123") // Belt.Result.Ok(("1", "2", "3"))
+|> P.runParser("123") // Result.Ok(("1", "2", "3"))
 
 // Combine parse results using a function via map2 through map5
 P.map2((a, b) => a + b, P.anyDigitAsInt, P.anyDigitAsInt)
-|> P.runParser("12") // Belt.Result.Ok(3)
+|> P.runParser("12") // Result.Ok(3)
 
 // Combine results from a tuple of parsers using mapTuple2 through mapTuple5
 (P.anyDigitAsInt, P.anyDigitAsInt)
 |> P.mapTuple2((a, b) => a + b)
-|> P.runParser("12"); // Belt.Result.Ok(3)
+|> P.runParser("12"); // Result.Ok(3)
 
 // Use the *> operator to run two parsers, and only keep the result from the right side
 // This is useful if you don't care what the left side parser produces (e.g. whitespace)
 // but you need to consume that input.
 // `ws` consumes all the whitespace it encounters and throws it away
 P.ws
 *> P.anyDigit
-|> P.runParser("   3") // Belt.Result.Ok("3")
+|> P.runParser("   3") // Result.Ok("3")
 
 // Use the <* operator to run two parsers, and only keep the result from the left side
 // This is useful if you don't care what the right side parser produces (e.g. whitespace)
@@ -190,7 +190,7 @@ P.ws
 *> P.anyDigit
 <* P.ws
 <* P.eof
-|> P.runParser("   3  ") // Belt.Result.Ok("3")
+|> P.runParser("   3  ") // Result.Ok("3")
 
 // ADVANCED: Incrementally collect parse results using a function and chained <$> map and <*> apply
 // operators.
@@ -199,7 +199,7 @@ add3
 <$> P.anyDigitAsInt
 <*> P.anyDigitAsInt
 <*> P.anyDigitAsInt
-|> P.runParser("123"); // Belt.Result.Ok(6)
+|> P.runParser("123"); // Result.Ok(6)
 ```
 
 Many of these functions and operators come for free for any Applicative via [Relude Apply Extensions](https://github.com/reazen/relude/blob/master/src/extensions/Relude_Extensions_Apply.re)
@@ -225,7 +225,7 @@ if a parser fails at some point in a chain, the rest of the parsers will not run
 // Lift a pure value into a parser.
 // As you can see the parser just produces the given value regardless of the string.
 P.pure(3)
-|> runParser("abcdef") // Belt.Result.Ok(3)
+|> runParser("abcdef") // Result.Ok(3)
 
 // Sequence parse operations using flatMap.
 // In this example we read a single digit as an int, then use that value
@@ -235,7 +235,7 @@ P.pure(3)
 P.anyDigitAsInt
 |> P.flatMap(count => P.anyAlpha |> P.times(count) <* P.eof)
 |> P.map(chars => Relude.List.String.join(chars))
-|> P.runParser("3abc"); // Belt.Result.Ok("abc")
+|> P.runParser("3abc"); // Result.Ok("abc")
 
 // Sequence using >>= (flatMap/bind) and <#> (map) operators.
 // If you are coming from JS -
@@ -245,7 +245,7 @@ P.anyDigitAsInt
 P.anyDigitAsInt
 >>= (count => P.times(count, P.anyAlpha) <* P.eof)
 <#> Relude.List.String.join
-|> P.runParser("3abc"); // Belt.Result.Ok("abc")
+|> P.runParser("3abc"); // Result.Ok("abc")
 ```
 
 Many of these functions come for free for any Monad via [Relude Monad Extensions](https://github.com/reazen/relude/blob/master/src/extensions/Relude_Extensions_Monad.re)
@@ -273,7 +273,7 @@ P.anyDigitAsInt
     }
 )
 <#> Relude.List.String.join
-|> runParser("9abc") // Belt.Result.Error(ParseError("The count cannot be >= 5"))
+|> runParser("9abc") // Result.Error(ParseError("The count cannot be >= 5"))
 ```
 
 The `filter` function in `ReludeParse` is basically for this purpose.  Filter produces its
@@ -293,9 +293,9 @@ if it fails, try another, as many times as you want.
 The `<|>` operator is used for this - think of the `<|>` operator as an `orElse` function.
 
 ```reason
-P.anyDigit <|> P.anyAlpha |> P.runParser("9") // Belt.Result.Ok("9")
-P.anyDigit <|> P.anyAlpha |> P.runParser("a") // Belt.Result.Ok("a")
-P.anyDigit <|> P.anyAlpha |> P.runParser("!") // Belt.Result.Error(...)
+P.anyDigit <|> P.anyAlpha |> P.runParser("9") // Result.Ok("9")
+P.anyDigit <|> P.anyAlpha |> P.runParser("a") // Result.Ok("a")
+P.anyDigit <|> P.anyAlpha |> P.runParser("!") // Result.Error(...)
 ```
 
 `<|>` can be chained as many times as you want - it attempts each parser left-to-right.
@@ -321,7 +321,7 @@ function to force a parser to back-track all the way to it's original position i
 // parser fully back-track on failure if it had consumed any input.
 P.tries(P.anyDigit *> P.anyDigit) // parse a digit, throw it away, then parse another digit
 <|> (P.anyDigit *> P.anyAlpha) // parse a digit,throw it away, then parse a letter
-|> P.runParser("9a") // Belt.Result.Ok("a")
+|> P.runParser("9a") // Result.Ok("a")
 ```
 
 # Customizing the error message
@@ -333,7 +333,7 @@ message if the parser fails.
 ```reason
 P.many1(P.anyDigit)
 <?> "Expected one or more digits"
-|> P.runParser("abc") // Belt.Result.Error(ParseError("Expected one or more digits"))
+|> P.runParser("abc") // Result.Error(ParseError("Expected one or more digits"))
 ```
 
 # Checking that all input is consumed
@@ -472,8 +472,8 @@ list of parser functions that come with `ReludeParse`.
 
 |Function|Description|Example|
 |--------|-----------|-------|
-|`runParser`|runs a parser with an input string to produce a `Belt.Result` with either the value or a `ParseError.t`
-|`unParser`|runs a parser with an input string to produce a `Belt.Result` with either the value or a `ParseError.t` (with some additional metadata compared to `runParser`)
+|`runParser`|runs a parser with an input string to produce a `Result` with either the value or a `ParseError.t`
+|`unParser`|runs a parser with an input string to produce a `Result` with either the value or a `ParseError.t` (with some additional metadata compared to `runParser`)
 
 ## Core FP functions and operators
 

__tests__/ReludeParse_Parser_test.res

@@ -7,19 +7,17 @@ open P.Infix
 let int_of_string = s => s->Int.fromString->Option.getUnsafe
 
 describe("ReludeParse_Parser", () => {
-  test("runParser success", () =>
-    expect(P.runParser("9", P.anyDigit))->toEqual(Belt.Result.Ok("9"))
-  )
+  test("runParser success", () => P.runParser("9", P.anyDigit)->expect->toEqual(Result.Ok("9")))
 
   test("runParser failure", () => {
     let expectedError: P.ParseError.t = ParseError("Expected a digit, but found character 'a'")
-    expect(P.runParser("a", P.anyDigit))->toEqual(Belt.Result.Error(expectedError))
+    P.runParser("a", P.anyDigit)->expect->toEqual(Result.Error(expectedError))
   })
 
   test("pure", () => {
-    let actual: Belt.Result.t<P.success<int>, P.error> =
+    let actual: Result.t<P.success<int>, P.error> =
       P.pure(42)->P.unParser({pos: 0, str: "whatever"}, _)
-    let expected: Belt.Result.t<P.success<int>, P.error> = Ok({
+    let expected: Result.t<P.success<int>, P.error> = Ok({
       result: 42,
       suffix: {
         pos: 0,
@@ -29,43 +27,43 @@ describe("ReludeParse_Parser", () => {
     expect(actual)->toEqual(expected)
   })
 
-  test("unit", () => testParse(P.unit, "whatever", (), {pos: 0, str: "whatever"}))
+  test("unit", () => P.unit->testParse("whatever", (), {pos: 0, str: "whatever"}))
 
   test("fail", () => {
     let actual = P.fail("Fail!")->P.unParser({pos: 0, str: "whatever"}, _)
-    let expected: Belt.Result.t<P.success<_>, P.error> = Belt.Result.Error({
+    let expected: Result.t<P.success<_>, P.error> = Result.Error({
       error: ParseError("Fail!"),
       pos: 0,
     })
     expect(actual)->toEqual(expected)
   })
 
   test("tries success", () =>
-    testParse(P.tries(P.times(3, P.anyDigit)), "012", list{"0", "1", "2"}, {pos: 3, str: "012"})
+    P.tries(P.times(3, P.anyDigit))->testParse("012", list{"0", "1", "2"}, {pos: 3, str: "012"})
   )
 
   test("without tries, error position is position of error", () =>
-    testParseFail(P.times(3, P.anyDigit), "01a", 2)
+    P.times(3, P.anyDigit)->testParseFail("01a", 2)
   )
 
   test("with tries, error position is the starting position", () =>
-    testParseFail(P.tries(P.times(3, P.anyDigit)), "01a", 0)
+    P.tries(P.times(3, P.anyDigit))->testParseFail("01a", 0)
   )
 
   test("withError", () =>
-    testParseFailWithMessage(P.withError("Fail!", P.anyDigit), "a", 0, "Fail!")
+    P.withError("Fail!", P.anyDigit)->testParseFailWithMessage("a", 0, "Fail!")
   )
 
   test("flipWithError", () =>
-    testParseFailWithMessage(P.flipWithError(P.anyDigit, "Fail!"), "a", 0, "Fail!")
+    P.flipWithError(P.anyDigit, "Fail!")->testParseFailWithMessage("a", 0, "Fail!")
   )
 
   test("<?> (withError operator)", () =>
-    testParseFailWithMessage(\"<?>"(P.anyDigit, "Fail!"), "a", 0, "Fail!")
+    \"<?>"(P.anyDigit, "Fail!")->testParseFailWithMessage("a", 0, "Fail!")
   )
 
   test("map/<$>/<#>", () =>
-    testParse(\"<$$>"(P.anyDigit, int_of_string), "9", 9, {pos: 1, str: "9"})
+    P.anyDigit->\"<$$>"(int_of_string)->testParse("9", 9, {pos: 1, str: "9"})
   )
 
   test("tap", () => {
@@ -75,67 +73,63 @@ describe("ReludeParse_Parser", () => {
 
     let result =
       P.anyDigit
-      ->(P.tap(
+      ->P.tap(
         (result, posStringBefore, posStringAfter) => {
           resultRef := result
           posStringBeforeRef := posStringBefore
           posStringAfterRef := posStringAfter
         },
         _,
-      ))
+      )
       ->P.runParser("1", _)
 
     expect((
       resultRef.contents,
       posStringBeforeRef.contents,
       posStringAfterRef.contents,
       result,
-    ))->toEqual(("1", P.PosString.make(0, "1"), P.PosString.make(1, "1"), Belt.Result.Ok("1")))
+    ))->toEqual(("1", P.PosString.make(0, "1"), P.PosString.make(1, "1"), Result.Ok("1")))
   })
 
-  test("tapLog", () => expect(P.anyDigit->P.tapLog->(P.runParser("1", _))->ignore)->toEqual())
+  test("tapLog", () => expect(P.anyDigit->P.tapLog->P.runParser("1", _)->ignore)->toEqual())
 
   test("apply/<*>", () =>
-    testParse(\"<*>"(P.pure(int_of_string), P.anyDigit), "9", 9, {pos: 1, str: "9"})
+    P.pure(int_of_string)->\"<*>"(P.anyDigit)->testParse("9", 9, {pos: 1, str: "9"})
   )
 
   test("<^> (tuple2 operator)", () =>
-    testParse(\"<^>"(P.anyDigit, P.anyDigit), "01", ("0", "1"), {pos: 2, str: "01"})
+    P.anyDigit->\"<^>"(P.anyDigit)->testParse("01", ("0", "1"), {pos: 2, str: "01"})
   )
 
   test("mapN (applicative extensions)", () =>
-    testParse(
-      P.map3((a, b, c) => (a, b, c), P.anyDigit, P.anyDigit, P.anyDigit),
+    P.map3((a, b, c) => (a, b, c), P.anyDigit, P.anyDigit, P.anyDigit)->testParse(
       "012",
       ("0", "1", "2"),
       {pos: 3, str: "012"},
     )
   )
 
   test("tupleN (applicative extensions)", () =>
-    testParse(
-      P.tuple3(P.anyDigit, P.anyDigit, P.anyDigit),
+    P.tuple3(P.anyDigit, P.anyDigit, P.anyDigit)->testParse(
       "012",
       ("0", "1", "2"),
       {pos: 3, str: "012"},
     )
   )
 
   test("mapTupleN (applicative extensions)", () =>
-    testParse(
-      (P.anyDigit, P.anyDigit, P.anyDigit)->P.mapTuple3((a, b, c) => (a, b, c), _),
-      "012",
-      ("0", "1", "2"),
-      {pos: 3, str: "012"},
-    )
+    (P.anyDigit, P.anyDigit, P.anyDigit)
+    ->P.mapTuple3((a, b, c) => (a, b, c), _)
+    ->testParse("012", ("0", "1", "2"), {pos: 3, str: "012"})
   )
 
   test("*>", () =>
-    testParse(\"<*"(\"*>"(P.anyDigit, P.anyDigit), P.eof), "12", "2", {pos: 2, str: "12"})
+    P.anyDigit->\"*>"(P.anyDigit)->\"<*"(P.eof)
+      ->testParse("12", "2", {pos: 2, str: "12"})
   )
 
   test("<*", () =>
-    testParse(\"<*"(\"<*"(P.anyDigit, P.anyDigit), P.eof), "12", "1", {pos: 2, str: "12"})
+    P.anyDigit->\"<*"(P.anyDigit)->\"<*"(P.eof)->testParse("12", "1", {pos: 2, str: "12"})
   )
 
   test("bind/flatMap/>>=", () => {
@@ -158,7 +152,7 @@ describe("ReludeParse_Parser", () => {
 
   test("throwError", () => {
     let actual = P.throwError(P.ParseError.make("hi"))->P.unParser({pos: 0, str: "whatever"}, _)
-    let expected: Belt.Result.t<P.success<_>, P.error> = Belt.Result.Error({
+    let expected: Result.t<P.success<_>, P.error> = Result.Error({
       error: ParseError("hi"),
       pos: 0,
     })
@@ -1194,7 +1188,7 @@ describe("ReludeParse_Parser", () => {
       ->\"<$>"(P.ws->\"*>"(P.anyDigitAsInt))
       ->\"<*>"(P.anyDigitAsInt)
       ->P.runParser("   34", _)
-    expect(x)->toEqual(Belt.Result.Ok(7))
+    expect(x)->toEqual(Result.Ok(7))
   })
 
   test("anyCharNotIn success", () =>