@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Pretty.Doc/index.js

@@ -0,0 +1,139 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dString$dCodePoints from "../Data.String.CodePoints/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const $Doc = (tag, _1, _2) => ({tag, _1, _2});
+const $Format = tag => tag;
+const $Mode = tag => tag;
+const Stmt = /* #__PURE__ */ $Mode("Stmt");
+const Expr = /* #__PURE__ */ $Mode("Expr");
+const Inline = /* #__PURE__ */ $Format("Inline");
+const Multiline = /* #__PURE__ */ $Format("Multiline");
+const Empty = /* #__PURE__ */ $Doc("Empty");
+const Line = /* #__PURE__ */ $Doc("Line");
+const Text = value0 => $Doc("Text", value0);
+const Indent = value0 => $Doc("Indent", value0);
+const Concat = value0 => value1 => $Doc("Concat", value0, value1);
+const Mode = value0 => value1 => $Doc("Mode", value0, value1);
+const StmtOrExpr = value0 => value1 => $Doc("StmtOrExpr", value0, value1);
+const InlOrMul = value0 => value1 => $Doc("InlOrMul", value0, value1);
+const semigroupDoc = {append: Concat};
+const monoidDoc = {mempty: Empty, Semigroup0: () => semigroupDoc};
+const width = m => doc => {
+  if (doc.tag === "Empty") { return 0; }
+  if (doc.tag === "Line") { return 0; }
+  if (doc.tag === "Text") { return Data$dString$dCodePoints.toCodePointArray(doc._1).length; }
+  if (doc.tag === "Indent") { return width(m)(doc._1); }
+  if (doc.tag === "Concat") { return width(m)(doc._1) + width(m)(doc._2) | 0; }
+  if (doc.tag === "Mode") { return width(doc._1)(doc._2); }
+  if (doc.tag === "StmtOrExpr") {
+    if (m === "Stmt") { return width(m)(doc._1); }
+    if (m === "Expr") { return width(m)(doc._2); }
+    $runtime.fail();
+  }
+  if (doc.tag === "InlOrMul") { return width(m)(doc._1); }
+  $runtime.fail();
+};
+const text = Text;
+const stmtOrExpr = StmtOrExpr;
+const stmt = /* #__PURE__ */ Mode(Stmt);
+const spaces = n => {
+  if (n <= 0) { return ""; }
+  return " " + spaces(n - 1 | 0);
+};
+const line = Line;
+const inlinable = m => doc => {
+  if (doc.tag === "Empty") { return true; }
+  if (doc.tag === "Line") { return false; }
+  if (doc.tag === "Text") { return true; }
+  if (doc.tag === "Indent") { return false; }
+  if (doc.tag === "Concat") { return inlinable(m)(doc._1) && inlinable(m)(doc._2); }
+  if (doc.tag === "Mode") { return inlinable(doc._1)(doc._2); }
+  if (doc.tag === "StmtOrExpr") {
+    if (m === "Stmt") { return false; }
+    if (m === "Expr") { return inlinable(m)(doc._2); }
+    $runtime.fail();
+  }
+  if (doc.tag === "InlOrMul") { return inlinable(m)(doc._1); }
+  $runtime.fail();
+};
+const inlOrMul = InlOrMul;
+const indent = Indent;
+const expr = /* #__PURE__ */ Mode(Expr);
+const empty = Empty;
+const config = {indentation: 2, lineWidth: 80};
+const format = m => w => doc => {
+  if (inlinable(m)(doc) && width(m)(doc) < (80 - w | 0)) { return Inline; }
+  return Multiline;
+};
+const renderWithIndent = m => i => w => doc => {
+  const indentation = i * 2 | 0;
+  const fmt = format(m)(w)(doc);
+  const $0 = (d1, d2) => {
+    const v = renderWithIndent(m)(i)(w)(d1);
+    const v1 = renderWithIndent(m)(i)(v._2)(d2);
+    return Data$dTuple.$Tuple(v._1 + v1._1, v1._2);
+  };
+  if (doc.tag === "Empty") { return Data$dTuple.$Tuple("", w); }
+  if (doc.tag === "Line") { return Data$dTuple.$Tuple(indentation <= 0 ? "\n" : "\n " + spaces(indentation - 1 | 0), indentation); }
+  if (doc.tag === "Concat") {
+    if (doc._1.tag === "Line") {
+      if (doc._2.tag === "Empty") { return Data$dTuple.$Tuple("\n", 0); }
+      if (doc._2.tag === "Line") { return Data$dTuple.$Tuple(indentation <= 0 ? "\n\n" : "\n\n " + spaces(indentation - 1 | 0), indentation); }
+    }
+    return $0(doc._1, doc._2);
+  }
+  if (doc.tag === "Text") { return Data$dTuple.$Tuple(doc._1, w + Data$dString$dCodePoints.toCodePointArray(doc._1).length | 0); }
+  if (doc.tag === "Indent") { return renderWithIndent(m)(i + 1 | 0)(w)(doc._1); }
+  if (doc.tag === "Mode") { return renderWithIndent(doc._1)(i)(w)(doc._2); }
+  if (doc.tag === "StmtOrExpr") {
+    if (m === "Stmt") { return renderWithIndent(m)(i)(w)(doc._1); }
+    if (m === "Expr") { return renderWithIndent(m)(i)(w)(doc._2); }
+    $runtime.fail();
+  }
+  if (doc.tag === "InlOrMul") {
+    if (fmt === "Inline") { return renderWithIndent(m)(i)(w)(doc._1); }
+    if (fmt === "Multiline") { return renderWithIndent(m)(i)(w)(doc._2); }
+  }
+  $runtime.fail();
+};
+const render = d => renderWithIndent(Stmt)(0)(0)(d)._1;
+const beside = a => b => $Doc("Concat", a, $Doc("Concat", $Doc("Text", " "), b));
+const above = a => b => $Doc("Concat", a, $Doc("Concat", Line, b));
+const sep = a => b => $Doc("InlOrMul", $Doc("Concat", a, $Doc("Concat", $Doc("Text", " "), b)), $Doc("Concat", a, $Doc("Concat", Line, b)));
+export {
+  $Doc,
+  $Format,
+  $Mode,
+  Concat,
+  Empty,
+  Expr,
+  Indent,
+  InlOrMul,
+  Inline,
+  Line,
+  Mode,
+  Multiline,
+  Stmt,
+  StmtOrExpr,
+  Text,
+  above,
+  beside,
+  config,
+  empty,
+  expr,
+  format,
+  indent,
+  inlOrMul,
+  inlinable,
+  line,
+  monoidDoc,
+  render,
+  renderWithIndent,
+  semigroupDoc,
+  sep,
+  spaces,
+  stmt,
+  stmtOrExpr,
+  text,
+  width
+};

package/output-es/Pretty.Util/index.js

@@ -0,0 +1,90 @@
+import * as $runtime from "../runtime.js";
+import * as Pretty$dDoc from "../Pretty.Doc/index.js";
+const vsep = v => {
+  if (v.tag === "Nil") { return Pretty$dDoc.Empty; }
+  if (v.tag === "Cons") {
+    if (v._2.tag === "Nil") { return v._1; }
+    return Pretty$dDoc.$Doc("Concat", v._1, Pretty$dDoc.$Doc("Concat", Pretty$dDoc.Line, vsep(v._2)));
+  }
+  $runtime.fail();
+};
+const sep$p = v => v1 => {
+  if (v1.tag === "Nil") { return Pretty$dDoc.Empty; }
+  if (v1.tag === "Cons") {
+    if (v1._2.tag === "Nil") { return v1._1; }
+    return Pretty$dDoc.$Doc("Concat", v1._1, Pretty$dDoc.$Doc("Concat", v, sep$p(v)(v1._2)));
+  }
+  $runtime.fail();
+};
+const sep = v => {
+  if (v.tag === "Nil") { return Pretty$dDoc.Empty; }
+  if (v.tag === "Cons") {
+    if (v._2.tag === "Nil") { return v._1; }
+    return Pretty$dDoc.$Doc("Concat", v._1, sep(v._2));
+  }
+  $runtime.fail();
+};
+const record = ds => Pretty$dDoc.$Doc(
+  "InlOrMul",
+  Pretty$dDoc.$Doc(
+    "Concat",
+    Pretty$dDoc.$Doc("Text", "{"),
+    Pretty$dDoc.$Doc(
+      "Concat",
+      Pretty$dDoc.$Doc("Text", " "),
+      Pretty$dDoc.$Doc("Concat", sep$p(Pretty$dDoc.$Doc("Text", ", "))(ds), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", " "), Pretty$dDoc.$Doc("Text", "}")))
+    )
+  ),
+  Pretty$dDoc.$Doc(
+    "Concat",
+    Pretty$dDoc.$Doc("Text", "{"),
+    Pretty$dDoc.$Doc(
+      "Concat",
+      Pretty$dDoc.$Doc("Indent", Pretty$dDoc.$Doc("Concat", Pretty$dDoc.Line, sep$p(Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", ","), Pretty$dDoc.Line))(ds))),
+      Pretty$dDoc.$Doc("Concat", Pretty$dDoc.Line, Pretty$dDoc.$Doc("Text", "}"))
+    )
+  )
+);
+const number = dictShow => s => Pretty$dDoc.$Doc("Text", dictShow.show(s));
+const matrix = p => Pretty$dDoc.$Doc(
+  "Concat",
+  Pretty$dDoc.$Doc(
+    "InlOrMul",
+    Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "[|"), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", " "), p)),
+    Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "[|"), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.Line, p))
+  ),
+  Pretty$dDoc.$Doc("Text", "|]")
+);
+const hsep = v => {
+  if (v.tag === "Nil") { return Pretty$dDoc.Empty; }
+  if (v.tag === "Cons") {
+    if (v._2.tag === "Nil") { return v._1; }
+    return Pretty$dDoc.$Doc("Concat", v._1, Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", " "), hsep(v._2)));
+  }
+  $runtime.fail();
+};
+const enclose = l => r => d => Pretty$dDoc.$Doc("Concat", l, Pretty$dDoc.$Doc("Concat", d, r));
+const parens = d => Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "("), Pretty$dDoc.$Doc("Concat", d, Pretty$dDoc.$Doc("Text", ")")));
+const pair = f => x => y => Pretty$dDoc.$Doc(
+  "Concat",
+  Pretty$dDoc.$Doc("Text", "("),
+  Pretty$dDoc.$Doc(
+    "Concat",
+    Pretty$dDoc.$Doc("Concat", f(x), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", ","), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", " "), f(y)))),
+    Pretty$dDoc.$Doc("Text", ")")
+  )
+);
+const quotes = d => Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "\""), Pretty$dDoc.$Doc("Concat", d, Pretty$dDoc.$Doc("Text", "\"")));
+const string = s => Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "\""), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", s), Pretty$dDoc.$Doc("Text", "\"")));
+const brackets = d => Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "["), Pretty$dDoc.$Doc("Concat", d, Pretty$dDoc.$Doc("Text", "]")));
+const braces = d => Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", "{"), Pretty$dDoc.$Doc("Concat", d, Pretty$dDoc.$Doc("Text", "}")));
+const block = d => Pretty$dDoc.$Doc(
+  "StmtOrExpr",
+  Pretty$dDoc.$Doc(
+    "Concat",
+    Pretty$dDoc.$Doc("Text", ":"),
+    Pretty$dDoc.$Doc("InlOrMul", Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", " "), d), Pretty$dDoc.$Doc("Indent", Pretty$dDoc.$Doc("Concat", Pretty$dDoc.Line, d)))
+  ),
+  Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", ":"), Pretty$dDoc.$Doc("Concat", Pretty$dDoc.$Doc("Text", " "), Pretty$dDoc.$Doc("Concat", d, Pretty$dDoc.$Doc("Text", ";"))))
+);
+export {block, braces, brackets, enclose, hsep, matrix, number, pair, parens, quotes, record, sep, sep$p, string, vsep};

package/output-es/Primitive/index.js

@@ -0,0 +1,304 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dCategory from "../Control.Category/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dProfunctor$dChoice from "../Data.Profunctor.Choice/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Graph from "../Graph/index.js";
+import * as Pretty from "../Pretty/index.js";
+import * as Pretty$dDoc from "../Pretty.Doc/index.js";
+import * as Val from "../Val/index.js";
+const fanin = /* #__PURE__ */ Data$dProfunctor$dChoice.fanin(Control$dCategory.categoryFn)(Data$dProfunctor$dChoice.choiceFn);
+const isZeroNumber = {isZero: $0 => 0.0 === $0};
+const isZeroInt = {isZero: $0 => 0 === $0};
+const unpack = toFrom => v => Data$dTuple.$Tuple(toFrom.unpack(v._3), v._1);
+const union1 = v => v1 => v2 => {
+  if (v2.tag === "Left") { return v(v2._1); }
+  if (v2.tag === "Right") { return v1(v2._1); }
+  $runtime.fail();
+};
+const unary = dictBoundedJoinSemilattice => {
+  const bot = dictBoundedJoinSemilattice.bot;
+  return id => f => Data$dTuple.$Tuple(
+    id,
+    Val.$Val(
+      bot,
+      Data$dMaybe.Nothing,
+      Val.$BaseVal(
+        "Fun",
+        Val.$Fun(
+          "Foreign",
+          Data$dTuple.$Tuple(
+            id,
+            Val.$ForeignOp$p({
+              arity: 1,
+              op: dictMonadWithGraphAlloc => {
+                const val = Val.val(dictMonadWithGraphAlloc);
+                return dictMonadError => dictMonadAff => dictMonadReader => dictLoadFile => doc_opt => v => {
+                  if (v.tag === "Cons" && v._2.tag === "Nil") {
+                    return val(doc_opt)(Data$dMap$dInternal.$$$Map("Node", 1, 1, v._1._1, undefined, Data$dMap$dInternal.Leaf, Data$dMap$dInternal.Leaf))(f.o.pack(f.fwd(f.i.unpack(v._1._3))));
+                  }
+                  $runtime.fail();
+                };
+              }
+            })
+          ),
+          Data$dList$dTypes.Nil
+        )
+      )
+    )
+  );
+};
+const typeError = v => typeName => Effect$dException.throwException(Effect$dException.error(typeName + " expected; got " + Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(Pretty.prettyBaseVal(Val.highlightableUnit).pretty(Val.functorBaseVal.map(v$1 => {})(v)))._1))();
+const string = {
+  pack: Val.Str,
+  unpack: v => {
+    if (v.tag === "Str") { return v._1; }
+    return typeError(v)("Str");
+  }
+};
+const pack = toFrom => v => Val.$Val(v._2, Data$dMaybe.Nothing, toFrom.pack(v._1));
+const number = {
+  pack: Val.Float,
+  unpack: v => {
+    if (v.tag === "Float") { return v._1; }
+    return typeError(v)("Float");
+  }
+};
+const matrixRep = {
+  pack: Val.Matrix,
+  unpack: v => {
+    if (v.tag === "Matrix") { return v._1; }
+    return typeError(v)("Matrix");
+  }
+};
+const isZero = dict1 => dict1.isZero;
+const isZero$x43 = dictIsZero => {
+  const isZero1 = dictIsZero.isZero;
+  return dictIsZero1 => ({isZero: fanin(isZero1)(dictIsZero1.isZero)});
+};
+const intOrNumberOrString = {
+  pack: v => {
+    if (v.tag === "Left") { return Val.$BaseVal("Int", v._1); }
+    if (v.tag === "Right") {
+      if (v._1.tag === "Left") { return Val.$BaseVal("Float", v._1._1); }
+      if (v._1.tag === "Right") { return Val.$BaseVal("Str", v._1._1); }
+    }
+    $runtime.fail();
+  },
+  unpack: v => {
+    if (v.tag === "Int") { return Data$dEither.$Either("Left", v._1); }
+    if (v.tag === "Float") { return Data$dEither.$Either("Right", Data$dEither.$Either("Left", v._1)); }
+    if (v.tag === "Str") { return Data$dEither.$Either("Right", Data$dEither.$Either("Right", v._1)); }
+    return typeError(v)("Int, Float or Str");
+  }
+};
+const intOrNumber = {
+  pack: v => {
+    if (v.tag === "Left") { return Val.$BaseVal("Int", v._1); }
+    if (v.tag === "Right") { return Val.$BaseVal("Float", v._1); }
+    $runtime.fail();
+  },
+  unpack: v => {
+    if (v.tag === "Int") { return Data$dEither.$Either("Left", v._1); }
+    if (v.tag === "Float") { return Data$dEither.$Either("Right", v._1); }
+    return typeError(v)("Int or Float");
+  }
+};
+const $$int = {
+  pack: Val.Int,
+  unpack: v => {
+    if (v.tag === "Int") { return v._1; }
+    return typeError(v)("Int");
+  }
+};
+const intPair = {
+  pack: v => Val.$BaseVal(
+    "Constr",
+    "Pair",
+    Data$dList$dTypes.$List(
+      "Cons",
+      Val.$Val(v._1._2, Data$dMaybe.Nothing, Val.$BaseVal("Int", v._1._1)),
+      Data$dList$dTypes.$List("Cons", Val.$Val(v._2._2, Data$dMaybe.Nothing, Val.$BaseVal("Int", v._2._1)), Data$dList$dTypes.Nil)
+    )
+  ),
+  unpack: v => {
+    if (v.tag === "Constr" && v._2.tag === "Cons" && v._2._2.tag === "Cons" && v._2._2._2.tag === "Nil" && v._1 === "Pair") {
+      return Data$dTuple.$Tuple(
+        Data$dTuple.$Tuple(v._2._1._3.tag === "Int" ? v._2._1._3._1 : typeError(v._2._1._3)("Int"), v._2._1._1),
+        Data$dTuple.$Tuple(v._2._2._1._3.tag === "Int" ? v._2._2._1._3._1 : typeError(v._2._2._1._3)("Int"), v._2._2._1._1)
+      );
+    }
+    return typeError(v)("Pair");
+  }
+};
+const dict = {
+  pack: x => Val.$BaseVal("Dictionary", x),
+  unpack: v => {
+    if (v.tag === "Dictionary") { return v._1; }
+    return typeError(v)("Dictionary");
+  }
+};
+const $$boolean = {
+  pack: v => {
+    if (v) { return Val.$BaseVal("Constr", "True", Data$dList$dTypes.Nil); }
+    return Val.$BaseVal("Constr", "False", Data$dList$dTypes.Nil);
+  },
+  unpack: v => {
+    if (v.tag === "Constr" && v._2.tag === "Nil") {
+      if (v._1 === "True") { return true; }
+      if (v._1 === "False") { return false; }
+    }
+    return typeError(v)("Boolean");
+  }
+};
+const binaryZero = dictBoundedJoinSemilattice => {
+  const bot = dictBoundedJoinSemilattice.bot;
+  return dictIsZero => id => f => Data$dTuple.$Tuple(
+    id,
+    Val.$Val(
+      bot,
+      Data$dMaybe.Nothing,
+      Val.$BaseVal(
+        "Fun",
+        Val.$Fun(
+          "Foreign",
+          Data$dTuple.$Tuple(
+            id,
+            Val.$ForeignOp$p({
+              arity: 2,
+              op: dictMonadWithGraphAlloc => {
+                const val = Val.val(dictMonadWithGraphAlloc);
+                return dictMonadError => dictMonadAff => dictMonadReader => dictLoadFile => doc_opt => v => {
+                  if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
+                    const $0 = f.i.unpack(v._1._3);
+                    const $1 = f.i.unpack(v._2._1._3);
+                    return val(doc_opt)((() => {
+                      if (dictIsZero.isZero($0)) { return Data$dMap$dInternal.$$$Map("Node", 1, 1, v._1._1, undefined, Data$dMap$dInternal.Leaf, Data$dMap$dInternal.Leaf); }
+                      if (dictIsZero.isZero($1)) { return Data$dMap$dInternal.$$$Map("Node", 1, 1, v._2._1._1, undefined, Data$dMap$dInternal.Leaf, Data$dMap$dInternal.Leaf); }
+                      return Data$dMap$dInternal.insert(Graph.ordVertex)(v._2._1._1)()(Data$dMap$dInternal.$$$Map(
+                        "Node",
+                        1,
+                        1,
+                        v._1._1,
+                        undefined,
+                        Data$dMap$dInternal.Leaf,
+                        Data$dMap$dInternal.Leaf
+                      ));
+                    })())(f.o.pack(f.fwd($0)($1)));
+                  }
+                  $runtime.fail();
+                };
+              }
+            })
+          ),
+          Data$dList$dTypes.Nil
+        )
+      )
+    )
+  );
+};
+const binary = dictBoundedJoinSemilattice => {
+  const bot = dictBoundedJoinSemilattice.bot;
+  return id => f => Data$dTuple.$Tuple(
+    id,
+    Val.$Val(
+      bot,
+      Data$dMaybe.Nothing,
+      Val.$BaseVal(
+        "Fun",
+        Val.$Fun(
+          "Foreign",
+          Data$dTuple.$Tuple(
+            id,
+            Val.$ForeignOp$p({
+              arity: 2,
+              op: dictMonadWithGraphAlloc => {
+                const val = Val.val(dictMonadWithGraphAlloc);
+                return dictMonadError => dictMonadAff => dictMonadReader => dictLoadFile => doc_opt => v => {
+                  if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
+                    return val(doc_opt)(Data$dMap$dInternal.insert(Graph.ordVertex)(v._2._1._1)()(Data$dMap$dInternal.$$$Map(
+                      "Node",
+                      1,
+                      1,
+                      v._1._1,
+                      undefined,
+                      Data$dMap$dInternal.Leaf,
+                      Data$dMap$dInternal.Leaf
+                    )))(f.o.pack(f.fwd(f.i1.unpack(v._1._3))(f.i2.unpack(v._2._1._3))));
+                  }
+                  $runtime.fail();
+                };
+              }
+            })
+          ),
+          Data$dList$dTypes.Nil
+        )
+      )
+    )
+  );
+};
+const asNumberString = {as: v => Effect$dException.throwException(Effect$dException.error("Non-uniform argument types"))()};
+const asNumberIntOrNumber = {as: Data$dEither.Right};
+const asIntNumberOrString = {as: x => Data$dEither.$Either("Left", Data$dInt.toNumber(x))};
+const asIntNumber = {as: Data$dInt.toNumber};
+const asIntIntOrNumber = {as: Data$dEither.Left};
+const asBooleanBoolean = {as: x => x};
+const as = dict1 => dict1.as;
+const asIntorNumberNumber = {
+  as: v => {
+    if (v.tag === "Left") { return Data$dInt.toNumber(v._1); }
+    if (v.tag === "Right") { return v._1; }
+    $runtime.fail();
+  }
+};
+const union = dictAs => dictAs1 => dictAs2 => dictAs3 => v => v1 => v2 => v3 => {
+  if (v2.tag === "Left") {
+    if (v3.tag === "Left") { return dictAs.as(v(v2._1)(v3._1)); }
+    if (v3.tag === "Right") { return dictAs1.as(v1(dictAs2.as(v2._1))(v3._1)); }
+    $runtime.fail();
+  }
+  if (v2.tag === "Right") {
+    if (v3.tag === "Right") { return dictAs1.as(v1(v2._1)(v3._1)); }
+    if (v3.tag === "Left") { return dictAs1.as(v1(v2._1)(dictAs3.as(v3._1))); }
+  }
+  $runtime.fail();
+};
+const unionStr = dictAs => dictAs1 => union(dictAs)(dictAs)(dictAs1)(dictAs1);
+export {
+  as,
+  asBooleanBoolean,
+  asIntIntOrNumber,
+  asIntNumber,
+  asIntNumberOrString,
+  asIntorNumberNumber,
+  asNumberIntOrNumber,
+  asNumberString,
+  binary,
+  binaryZero,
+  $$boolean as boolean,
+  dict,
+  fanin,
+  $$int as int,
+  intOrNumber,
+  intOrNumberOrString,
+  intPair,
+  isZero,
+  isZero$x43,
+  isZeroInt,
+  isZeroNumber,
+  matrixRep,
+  number,
+  pack,
+  string,
+  typeError,
+  unary,
+  union,
+  union1,
+  unionStr,
+  unpack
+};