@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/Parsing.Combinators.Array/index.js

@@ -0,0 +1,131 @@
+// | These combinators will produce `Array`s, as opposed to the other combinators
+// | of the same names in the __Parsing.Combinators__ module
+// | which mostly produce `List`s. These `Array` combinators will run in a bit
+// | less time (*~85% runtime*) than the similar `List` combinators, and they will run in a
+// | lot less time (*~10% runtime*) than the similar combinators in __Data.Array__.
+// |
+// | If there is some other combinator which returns
+// | a `List` but we want an `Array`, and there is no `Array` version of the
+// | combinator in this module, then we can rely on the
+// | [__`Data.Array.fromFoldable`__](https://pursuit.purescript.org/packages/purescript-arrays/docs/Data.Array#v:fromFoldable)
+// | function for a pretty fast transformation from `List` to `Array`.
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Parsing from "../Parsing/index.js";
+const manyTill_ = p => end => {
+  const $0 = Parsing.monadRecParserT.tailRecM(xs => (v2, $0, $1, $2, $3) => {
+    const $4 = v2._1;
+    const $5 = v2._2;
+    return $0(v3 => $0(v1 => end(
+      Parsing.$ParseState($4, $5, false),
+      $0,
+      $1,
+      (v4, $6) => {
+        const $7 = v4._3;
+        return $0(v5 => {
+          if ($7) { return $2(v4, $6); }
+          return $0(v1$1 => p(
+            v2,
+            $0,
+            $1,
+            $2,
+            (state2, a) => $0(v2$1 => $3(
+              v2._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2,
+              Control$dMonad$dRec$dClass.$Step("Loop", Data$dList$dTypes.$List("Cons", a, xs))
+            ))
+          ));
+        });
+      },
+      (state2, a) => $0(v2$1 => $3(state2, Control$dMonad$dRec$dClass.$Step("Done", Data$dTuple.$Tuple(xs, a))))
+    )));
+  })(Data$dList$dTypes.Nil);
+  return (state1, more, lift1, $$throw, done) => more(v1 => $0(
+    state1,
+    more,
+    lift1,
+    $$throw,
+    (state2, a) => more(v2 => done(
+      state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2,
+      Data$dTuple.$Tuple(Data$dArray.reverse(Data$dArray.fromFoldableImpl(Data$dList$dTypes.foldableList.foldr, a._1)), a._2)
+    ))
+  ));
+};
+const manyIndex = from => to => p => {
+  if (from > to || from < 0) { return (state1, v, v1, v2, done) => done(state1, Data$dTuple.$Tuple(0, [])); }
+  const $0 = Parsing.monadRecParserT.tailRecM(v => {
+    if (v._1 >= to) { return (state1, v$1, v1, v2, done) => done(state1, Control$dMonad$dRec$dClass.$Step("Done", Data$dTuple.$Tuple(v._1, v._2))); }
+    const $0 = p(v._1);
+    return (state1, more, lift1, $$throw, done) => more(v1 => more(v1$1 => $0(
+      state1,
+      more,
+      lift1,
+      (state2, err) => {
+        if (v._1 >= from) { return done(state2, Control$dMonad$dRec$dClass.$Step("Done", Data$dTuple.$Tuple(v._1, v._2))); }
+        return $$throw(state2, Parsing.$ParseError(err._1 + " (at least " + Data$dShow.showIntImpl(from) + ", but only parsed " + Data$dShow.showIntImpl(v._1) + ")", err._2));
+      },
+      (state2, a) => more(v2 => done(
+        state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2,
+        Control$dMonad$dRec$dClass.$Step("Loop", Data$dTuple.$Tuple(v._1 + 1 | 0, Data$dList$dTypes.$List("Cons", a, v._2)))
+      ))
+    )));
+  })(Data$dTuple.$Tuple(0, Data$dList$dTypes.Nil));
+  return (state1, more, lift1, $$throw, done) => more(v1 => $0(
+    state1,
+    more,
+    lift1,
+    $$throw,
+    (state2, a) => more(v2 => done(
+      state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2,
+      Data$dTuple.$Tuple(a._1, Data$dArray.reverse(Data$dArray.fromFoldableImpl(Data$dList$dTypes.foldableList.foldr, a._2)))
+    ))
+  ));
+};
+const many = p => {
+  const $0 = Parsing.monadRecParserT.tailRecM(xs => (v2, $0, $1, $2, $3) => {
+    const $4 = v2._1;
+    const $5 = v2._2;
+    return $0(v3 => $0(v1 => p(
+      Parsing.$ParseState($4, $5, false),
+      $0,
+      $1,
+      (v4, $6) => {
+        const $7 = v4._3;
+        return $0(v5 => {
+          if ($7) { return $2(v4, $6); }
+          return $3(v2, Control$dMonad$dRec$dClass.$Step("Done", xs));
+        });
+      },
+      (state2, a) => $0(v2$1 => $3(state2, Control$dMonad$dRec$dClass.$Step("Loop", Data$dList$dTypes.$List("Cons", a, xs))))
+    )));
+  })(Data$dList$dTypes.Nil);
+  return (state1, more, lift1, $$throw, done) => more(v1 => $0(
+    state1,
+    more,
+    lift1,
+    $$throw,
+    (state2, a) => more(v2 => done(
+      state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2,
+      Data$dArray.reverse(Data$dArray.fromFoldableImpl(Data$dList$dTypes.foldableList.foldr, a))
+    ))
+  ));
+};
+const many1 = p => {
+  const $0 = many(p);
+  return (state1, more, lift1, $$throw, done) => more(v1 => $0(
+    state1,
+    more,
+    lift1,
+    $$throw,
+    (state2, a) => more(v2 => (a.length > 0 ? ((state1$1, v, v1$1, v2$1, done$1) => done$1(state1$1, a)) : Parsing.fail("Expected at least 1"))(
+      state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2,
+      more,
+      lift1,
+      $$throw,
+      done
+    ))
+  ));
+};
+export {many, many1, manyIndex, manyTill_};

package/output-es/Parsing.Expr/index.js

@@ -0,0 +1,317 @@
+// | This module is a port of the Haskell
+// | [__Text.Parsec.Expr__](https://hackage.haskell.org/package/parsec/docs/Text-Parsec-Expr.html)
+// | module.
+import * as $runtime from "../runtime.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Parsing from "../Parsing/index.js";
+import * as Parsing$dCombinators from "../Parsing.Combinators/index.js";
+const $Assoc = tag => tag;
+const $Operator = (tag, _1, _2) => ({tag, _1, _2});
+const choice = /* #__PURE__ */ Parsing$dCombinators.choice(Data$dList$dTypes.foldableList);
+const AssocNone = /* #__PURE__ */ $Assoc("AssocNone");
+const AssocLeft = /* #__PURE__ */ $Assoc("AssocLeft");
+const AssocRight = /* #__PURE__ */ $Assoc("AssocRight");
+const Infix = value0 => value1 => $Operator("Infix", value0, value1);
+const Prefix = value0 => $Operator("Prefix", value0);
+const Postfix = value0 => $Operator("Postfix", value0);
+const termP = prefixP => term => postfixP => (state1, more, lift1, $$throw, done) => more(v1 => prefixP(
+  state1,
+  more,
+  lift1,
+  $$throw,
+  (state2, a) => more(v2 => {
+    const $0 = state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2;
+    return more(v1$1 => term(
+      $0,
+      more,
+      lift1,
+      $$throw,
+      (state2$1, a$1) => more(v2$1 => {
+        const $1 = $0._3 && !state2$1._3 ? Parsing.$ParseState(state2$1._1, state2$1._2, true) : state2$1;
+        return more(v1$2 => postfixP(
+          $1,
+          more,
+          lift1,
+          $$throw,
+          (state2$2, a$2) => more(v2$2 => done($1._3 && !state2$2._3 ? Parsing.$ParseState(state2$2._1, state2$2._2, true) : state2$2, a$2(a(a$1))))
+        ));
+      })
+    ));
+  })
+));
+const splitOp = v => v1 => {
+  if (v.tag === "Infix") {
+    if (v._2 === "AssocNone") { return {rassoc: v1.rassoc, lassoc: v1.lassoc, nassoc: Data$dList$dTypes.$List("Cons", v._1, v1.nassoc), prefix: v1.prefix, postfix: v1.postfix}; }
+    if (v._2 === "AssocLeft") { return {rassoc: v1.rassoc, lassoc: Data$dList$dTypes.$List("Cons", v._1, v1.lassoc), nassoc: v1.nassoc, prefix: v1.prefix, postfix: v1.postfix}; }
+    if (v._2 === "AssocRight") { return {rassoc: Data$dList$dTypes.$List("Cons", v._1, v1.rassoc), lassoc: v1.lassoc, nassoc: v1.nassoc, prefix: v1.prefix, postfix: v1.postfix}; }
+    $runtime.fail();
+  }
+  if (v.tag === "Prefix") { return {rassoc: v1.rassoc, lassoc: v1.lassoc, nassoc: v1.nassoc, prefix: Data$dList$dTypes.$List("Cons", v._1, v1.prefix), postfix: v1.postfix}; }
+  if (v.tag === "Postfix") { return {rassoc: v1.rassoc, lassoc: v1.lassoc, nassoc: v1.nassoc, prefix: v1.prefix, postfix: Data$dList$dTypes.$List("Cons", v._1, v1.postfix)}; }
+  $runtime.fail();
+};
+const rchainP = p => {
+  const go = go$a0$copy => go$a1$copy => {
+    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+    while (go$c) {
+      const b = go$a0, v = go$a1;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = b;
+        continue;
+      }
+      if (v.tag === "Cons") {
+        go$a0 = v._1(b);
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const $0 = Parsing$dCombinators.manyRec(p);
+  return (state1, more, lift1, $$throw, done) => more(v1 => $0(state1, more, lift1, $$throw, (state2, a) => more(v2 => done(state2, a$1 => go(a$1)(a)))));
+};
+const rassocP1 = x => rassocOp => prefixP => term => postfixP => {
+  const $0 = rassocP(x)(rassocOp)(prefixP)(term)(postfixP);
+  return (v2, $1, $2, $3, $4) => {
+    const $5 = v2._1;
+    const $6 = v2._2;
+    return $1(v3 => $0(
+      Parsing.$ParseState($5, $6, false),
+      $1,
+      $2,
+      (v4, $7) => {
+        const $8 = v4._3;
+        return $1(v5 => {
+          if ($8) { return $3(v4, $7); }
+          return $4(v2, x);
+        });
+      },
+      $4
+    ));
+  };
+};
+const rassocP = x => rassocOp => prefixP => term => postfixP => (state1, more, lift1, $$throw, done) => more(v1 => rassocOp(
+  state1,
+  more,
+  lift1,
+  $$throw,
+  (state2, a) => more(v2 => {
+    const $0 = state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2;
+    return more(v1$1 => more(v1$2 => termP(prefixP)(term)(postfixP)(
+      $0,
+      more,
+      lift1,
+      $$throw,
+      (state2$1, a$1) => more(v2$1 => rassocP1(a$1)(rassocOp)(prefixP)(term)(postfixP)(
+        $0._3 && !state2$1._3 ? Parsing.$ParseState(state2$1._1, state2$1._2, true) : state2$1,
+        more,
+        lift1,
+        $$throw,
+        (state2$2, a$2) => more(v2$2 => done($0._3 && !state2$2._3 ? Parsing.$ParseState(state2$2._1, state2$2._2, true) : state2$2, a(x)(a$2)))
+      ))
+    )));
+  })
+));
+const nassocP = x => nassocOp => prefixP => term => postfixP => (state1, more, lift1, $$throw, done) => more(v1 => nassocOp(
+  state1,
+  more,
+  lift1,
+  $$throw,
+  (state2, a) => more(v2 => {
+    const $0 = state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2;
+    return more(v1$1 => termP(prefixP)(term)(postfixP)(
+      $0,
+      more,
+      lift1,
+      $$throw,
+      (state2$1, a$1) => more(v2$1 => done($0._3 && !state2$1._3 ? Parsing.$ParseState(state2$1._1, state2$1._2, true) : state2$1, a(x)(a$1)))
+    ));
+  })
+));
+const lchainP = p => {
+  const go = go$a0$copy => go$a1$copy => {
+    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+    while (go$c) {
+      const b = go$a0, v = go$a1;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = b;
+        continue;
+      }
+      if (v.tag === "Cons") {
+        go$a0 = v._1(b);
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const $0 = Parsing$dCombinators.manyRec(p);
+  return (state1, more, lift1, $$throw, done) => more(v1 => $0(
+    state1,
+    more,
+    lift1,
+    $$throw,
+    (state2, a) => more(v2 => done(
+      state2,
+      (() => {
+        const go$1 = go$1$a0$copy => go$1$a1$copy => {
+          let go$1$a0 = go$1$a0$copy, go$1$a1 = go$1$a1$copy, go$1$c = true, go$1$r;
+          while (go$1$c) {
+            const v = go$1$a0, v1$1 = go$1$a1;
+            if (v1$1.tag === "Nil") {
+              go$1$c = false;
+              go$1$r = v;
+              continue;
+            }
+            if (v1$1.tag === "Cons") {
+              go$1$a0 = Data$dList$dTypes.$List("Cons", v1$1._1, v);
+              go$1$a1 = v1$1._2;
+              continue;
+            }
+            $runtime.fail();
+          }
+          return go$1$r;
+        };
+        const $1 = go$1(Data$dList$dTypes.Nil)(a);
+        return a$1 => go(a$1)($1);
+      })()
+    ))
+  ));
+};
+const lassocP1 = x => lassocOp => prefixP => term => postfixP => {
+  const $0 = lassocP(x)(lassocOp)(prefixP)(term)(postfixP);
+  return (v2, $1, $2, $3, $4) => {
+    const $5 = v2._1;
+    const $6 = v2._2;
+    return $1(v3 => $0(
+      Parsing.$ParseState($5, $6, false),
+      $1,
+      $2,
+      (v4, $7) => {
+        const $8 = v4._3;
+        return $1(v5 => {
+          if ($8) { return $3(v4, $7); }
+          return $4(v2, x);
+        });
+      },
+      $4
+    ));
+  };
+};
+const lassocP = x => lassocOp => prefixP => term => postfixP => (state1, more, lift1, $$throw, done) => more(v1 => lassocOp(
+  state1,
+  more,
+  lift1,
+  $$throw,
+  (state2, a) => more(v2 => {
+    const $0 = state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2;
+    return more(v1$1 => termP(prefixP)(term)(postfixP)(
+      $0,
+      more,
+      lift1,
+      $$throw,
+      (state2$1, a$1) => more(v2$1 => lassocP1(a(x)(a$1))(lassocOp)(prefixP)(term)(postfixP)(
+        $0._3 && !state2$1._3 ? Parsing.$ParseState(state2$1._1, state2$1._2, true) : state2$1,
+        more,
+        lift1,
+        $$throw,
+        done
+      ))
+    ));
+  })
+));
+const makeParser = term => ops => {
+  const accum = Data$dFoldable.foldrArray(splitOp)({
+    rassoc: Data$dList$dTypes.Nil,
+    lassoc: Data$dList$dTypes.Nil,
+    nassoc: Data$dList$dTypes.Nil,
+    prefix: Data$dList$dTypes.Nil,
+    postfix: Data$dList$dTypes.Nil
+  })(ops);
+  const lassocOp = choice(accum.lassoc);
+  const nassocOp = choice(accum.nassoc);
+  const postfixP = rchainP(Parsing$dCombinators.withErrorMessage(choice(accum.postfix))(""));
+  const prefixP = lchainP(Parsing$dCombinators.withErrorMessage(choice(accum.prefix))(""));
+  const rassocOp = choice(accum.rassoc);
+  return (state1, more, lift1, $$throw, done) => more(v1 => termP(prefixP)(term)(postfixP)(
+    state1,
+    more,
+    lift1,
+    $$throw,
+    (state2, a) => more(v2 => {
+      const $0 = Parsing$dCombinators.withErrorMessage((state1$1, v, v1$1, v2$1, done$1) => done$1(state1$1, a))("operator");
+      const $1 = state1._3 && !state2._3 ? Parsing.$ParseState(state2._1, state2._2, true) : state2;
+      const $2 = $1._1;
+      const $3 = $1._2;
+      return more(v3 => rassocP(a)(rassocOp)(prefixP)(term)(postfixP)(
+        Parsing.$ParseState($2, $3, false),
+        more,
+        lift1,
+        (v4, $4) => {
+          const $5 = v4._3;
+          return more(v5 => {
+            if ($5) { return $$throw(v4, $4); }
+            const $6 = $1._1;
+            const $7 = $1._2;
+            return more(v3$1 => lassocP(a)(lassocOp)(prefixP)(term)(postfixP)(
+              Parsing.$ParseState($6, $7, false),
+              more,
+              lift1,
+              (v4$1, $8) => {
+                const $9 = v4$1._3;
+                return more(v5$1 => {
+                  if ($9) { return $$throw(v4$1, $8); }
+                  const $10 = $1._1;
+                  const $11 = $1._2;
+                  return more(v3$2 => nassocP(a)(nassocOp)(prefixP)(term)(postfixP)(
+                    Parsing.$ParseState($10, $11, false),
+                    more,
+                    lift1,
+                    (v4$2, $12) => {
+                      const $13 = v4$2._3;
+                      return more(v5$2 => {
+                        if ($13) { return $$throw(v4$2, $12); }
+                        return $0($1, more, lift1, $$throw, done);
+                      });
+                    },
+                    done
+                  ));
+                });
+              },
+              done
+            ));
+          });
+        },
+        done
+      ));
+    })
+  ));
+};
+const buildExprParser = operators => simpleExpr => Data$dFoldable.foldlArray(makeParser)(simpleExpr)(operators);
+export {
+  $Assoc,
+  $Operator,
+  AssocLeft,
+  AssocNone,
+  AssocRight,
+  Infix,
+  Postfix,
+  Prefix,
+  buildExprParser,
+  choice,
+  lassocP,
+  lassocP1,
+  lchainP,
+  makeParser,
+  nassocP,
+  rassocP,
+  rassocP1,
+  rchainP,
+  splitOp,
+  termP
+};