@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/Test.Specs.LinkedOutputs/index.js

@@ -0,0 +1,61 @@
+import * as $runtime from "../runtime.js";
+import * as App$dUtil from "../App.Util/index.js";
+import * as App$dUtil$dSelector from "../App.Util.Selector/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Val from "../Val/index.js";
+const select = b => Data$dTuple.$Tuple(
+  Val.functorVal.map(v => {
+    if (v.tag === "Inert") { return App$dUtil.Inert; }
+    if (v.tag === "Reactive") { return App$dUtil.$SelState("Reactive", {persistent: !v._1.persistent, transient: v._1.transient}); }
+    $runtime.fail();
+  })(b),
+  App$dUtil.Persistent
+);
+const movingAverages_spec = {
+  spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["methane"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+  "δ_out": x => Data$dTuple.$Tuple(x, App$dUtil.Persistent),
+  out_expect: x => Data$dTuple.$Tuple(x, App$dUtil.Persistent),
+  file: "linkedOutputs/moving-average.fld"
+};
+const linkedOutputs_spec2 = {
+  spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["nonRenewables"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+  "δ_out": /* #__PURE__ */ App$dUtil$dSelector.multiViewEntry(0)(/* #__PURE__ */ App$dUtil$dSelector.constrArg("BarChart")(0)(x => App$dUtil$dSelector.barSegment(4)(3)(select)(App$dUtil$dSelector.barSegment(4)(1)(select)(App$dUtil$dSelector.barSegment(3)(2)(select)(x)._1)._1))),
+  out_expect: /* #__PURE__ */ (() => {
+    const $0 = App$dUtil$dSelector.multiViewEntry(0)(App$dUtil$dSelector.constrArg("BarChart")(0)(x => App$dUtil$dSelector.barSegment(4)(3)(select)(App$dUtil$dSelector.barSegment(4)(1)(select)(App$dUtil$dSelector.barSegment(3)(2)(select)(x)._1)._1)));
+    const $1 = App$dUtil$dSelector.multiViewEntry(1)(App$dUtil$dSelector.constrArg("ScatterPlot")(0)(x => App$dUtil$dSelector.dictVal("points")(App$dUtil$dSelector.listElement(6)(App$dUtil$dSelector.dictVal("y")(select)))(App$dUtil$dSelector.dictVal("points")(App$dUtil$dSelector.listElement(4)(App$dUtil$dSelector.dictVal("y")(select)))(x)._1)));
+    return x => $1($0(x)._1);
+  })(),
+  file: "slicing/linkedOutputs/stacked-bar-scatter-plot.fld"
+};
+const linkedOutputs_spec1 = {
+  spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["renewables"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+  "δ_out": /* #__PURE__ */ App$dUtil$dSelector.multiViewEntry(0)(/* #__PURE__ */ App$dUtil$dSelector.constrArg("BarChart")(0)(/* #__PURE__ */ App$dUtil$dSelector.barSegment(1)(0)(select))),
+  out_expect: /* #__PURE__ */ (() => {
+    const $0 = App$dUtil$dSelector.multiViewEntry(1)(App$dUtil$dSelector.constrArg("LineChart")(0)(App$dUtil$dSelector.dictVal("plots")(x => App$dUtil$dSelector.listElement(3)(App$dUtil$dSelector.linePoint(2)(App$dUtil$dSelector.dictVal("y")(select)))(App$dUtil$dSelector.listElement(2)(App$dUtil$dSelector.linePoint(2)(App$dUtil$dSelector.dictVal("y")(select)))(App$dUtil$dSelector.listElement(1)(App$dUtil$dSelector.linePoint(2)(App$dUtil$dSelector.dictVal("y")(select)))(App$dUtil$dSelector.listElement(0)(App$dUtil$dSelector.linePoint(2)(App$dUtil$dSelector.dictVal("y")(select)))(x)._1)._1)._1))));
+    return x => $0(App$dUtil$dSelector.constrArg("MultiView")(0)(App$dUtil$dSelector.listElement(0)(App$dUtil$dSelector.constrArg("BarChart")(0)(App$dUtil$dSelector.barSegment(1)(0)(select))))(x)._1);
+  })(),
+  file: "slicing/linkedOutputs/bar-chart-line-chart.fld"
+};
+const linkedOutputs_cases = [
+  {
+    spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["data"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+    "δ_out": /* #__PURE__ */ App$dUtil$dSelector.constrArg("Pair")(1)(select),
+    out_expect: select,
+    file: "linkedOutputs/pairs.fld"
+  },
+  {
+    spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["data"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+    "δ_out": /* #__PURE__ */ App$dUtil$dSelector.constrArg("Pair")(0)(/* #__PURE__ */ App$dUtil$dSelector.matrixElement(1)(1)(select)),
+    out_expect: /* #__PURE__ */ (() => {
+      const $0 = App$dUtil$dSelector.constrArg("Pair")(0)(x => App$dUtil$dSelector.matrixElement(1)(4)(select)(App$dUtil$dSelector.matrixElement(1)(3)(select)(App$dUtil$dSelector.matrixElement(1)(2)(select)(App$dUtil$dSelector.matrixElement(1)(1)(select)(App$dUtil$dSelector.matrixElement(1)(0)(select)(x)._1)._1)._1)._1));
+      const $1 = App$dUtil$dSelector.constrArg("Pair")(1)(x => App$dUtil$dSelector.matrixElement(2)(2)(select)(App$dUtil$dSelector.matrixElement(2)(1)(select)(App$dUtil$dSelector.matrixElement(2)(0)(select)(App$dUtil$dSelector.matrixElement(1)(2)(select)(App$dUtil$dSelector.matrixElement(1)(1)(select)(App$dUtil$dSelector.matrixElement(1)(0)(select)(App$dUtil$dSelector.matrixElement(0)(2)(select)(App$dUtil$dSelector.matrixElement(0)(1)(select)(App$dUtil$dSelector.matrixElement(0)(0)(select)(x)._1)._1)._1)._1)._1)._1)._1)._1));
+      return x => $1($0(x)._1);
+    })(),
+    file: "linkedOutputs/convolution.fld"
+  },
+  linkedOutputs_spec1,
+  linkedOutputs_spec2,
+  movingAverages_spec
+];
+export {linkedOutputs_cases, linkedOutputs_spec1, linkedOutputs_spec2, movingAverages_spec, select};

package/output-es/Test.Specs.Misc/index.js

@@ -0,0 +1,35 @@
+const misc_cases = [
+  {file: "arithmetic.fld", fwd_expect: "42"},
+  {file: "array.fld", fwd_expect: "(0, (3, 3))"},
+  {file: "boolean-precedence.fld", fwd_expect: "True"},
+  {file: "compose.fld", fwd_expect: "5"},
+  {file: "custom-infix.fld", fwd_expect: "True"},
+  {file: "dicts.fld", fwd_expect: "{ d: {}, e: { a: 5, ab: 6 }, e_ab: 6, f: { a: 6, ab: 7 }, g: { a: 5 } }"},
+  {file: "div-mod-quot-rem.fld", fwd_expect: "(1 :| -2 :| -2 :| 1 :| []) :| (2 :| -1 :| 1 :| -2 :| []) :| (1 :| -1 :| -1 :| 1 :| []) :| (2 :| 2 :| -2 :| -2 :| []) :| []"},
+  {file: "elif.fld", fwd_expect: "\"much more\" :| \"more\" :| \"less\" :| \"much less\" :| []"},
+  {file: "factorial.fld", fwd_expect: "40320"},
+  {file: "filter.fld", fwd_expect: "8 :| 7 :| []"},
+  {file: "first-class-constr.fld", fwd_expect: "(10 :| []) :| (12 :| []) :| (20 :| []) :| []"},
+  {file: "flatten.fld", fwd_expect: "(3, \"simon\") :| (4, \"john\") :| (6, \"sarah\") :| (7, \"claire\") :| []"},
+  {file: "foldr-sumSquares.fld", fwd_expect: "661"},
+  {file: "include-input-into-output.fld", fwd_expect: "(1, 1)"},
+  {file: "lexicalScoping.fld", fwd_expect: "\"6\""},
+  {file: "length.fld", fwd_expect: "2"},
+  {file: "lookup.fld", fwd_expect: "Some(\"sarah\")"},
+  {file: "map.fld", fwd_expect: "5 :| 7 :| 13 :| 15 :| 4 :| 3 :| -3 :| []"},
+  {file: "mergeSort.fld", fwd_expect: "1 :| 2 :| 3 :| []"},
+  {file: "normalise.fld", fwd_expect: "(33, 66)"},
+  {file: "not-parens-op.fld", fwd_expect: "@doc(\"hello\") -42"},
+  {file: "nub.fld", fwd_expect: "1 :| 2 :| 3 :| 4 :| []"},
+  {file: "paragraph.fld", fwd_expect: "Paragraph(Text(\"As shown in Table 3, BiLSTM gives significantly  \") :| Text(\"better\") :| [])"},
+  {file: "pattern-match.fld", fwd_expect: "4"},
+  {file: "prefix-op.fld", fwd_expect: "True"},
+  {file: "range.fld", fwd_expect: "(0, 0) :| (0, 1) :| (1, 0) :| (1, 1) :| []"},
+  {file: "records.fld", fwd_expect: "{ a: 2, b: 6, c: 7, d: 5 :| [], e: 7 }"},
+  {file: "record-lookup.fld", fwd_expect: "True"},
+  {file: "reverse.fld", fwd_expect: "2 :| 1 :| []"},
+  {file: "module/import-simple.fld", fwd_expect: "84"},
+  {file: "module/import-simple-unused.fld", fwd_expect: "84"},
+  {file: "module/import-modules.fld", fwd_expect: "84"}
+];
+export {misc_cases};

package/output-es/Test.Specs.Paragraph/index.js

@@ -0,0 +1,5 @@
+const paragraph_cases = [
+  {file: "paragraph/basic.fld", fwd_expect: "Paragraph(\"Hello\" :| \"there,\" :| Paragraph(\"Alice\" :| []) :| \"!\" :| [])"},
+  {file: "paragraph/explicit.fld", fwd_expect: "Paragraph(Text(\"Hi \") :| \"Alice\" :| 5 :| \"+\" :| \"6\" :| \"is\" :| Text(\"16\") :| [])"}
+];
+export {paragraph_cases};

package/output-es/Test.Test/index.js

@@ -0,0 +1,106 @@
+import * as Control$dMonad$dReader$dTrans from "../Control.Monad.Reader.Trans/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Effect$dAff$dClass from "../Effect.Aff.Class/index.js";
+import * as File from "../File/index.js";
+import * as Test$dSpecs$dBwd from "../Test.Specs.Bwd/index.js";
+import * as Test$dSpecs$dComments from "../Test.Specs.Comments/index.js";
+import * as Test$dSpecs$dDesugar from "../Test.Specs.Desugar/index.js";
+import * as Test$dSpecs$dGraphics from "../Test.Specs.Graphics/index.js";
+import * as Test$dSpecs$dLinkedInputs from "../Test.Specs.LinkedInputs/index.js";
+import * as Test$dSpecs$dLinkedOutputs from "../Test.Specs.LinkedOutputs/index.js";
+import * as Test$dSpecs$dMisc from "../Test.Specs.Misc/index.js";
+import * as Test$dSpecs$dParagraph from "../Test.Specs.Paragraph/index.js";
+import * as Test$dUtil from "../Test.Util/index.js";
+import * as Test$dUtil$dMocha from "../Test.Util.Mocha/index.js";
+import * as Test$dUtil$dSuite from "../Test.Util.Suite/index.js";
+const scratchpad = dictMonadAff => {
+  const $$void = dictMonadAff.MonadEffect0().Monad0().Bind1().Apply0().Functor0().map(v => {});
+  return dictMonadError => dictMonadReader => {
+    const suite2 = Test$dUtil$dSuite.suite(dictMonadAff)(dictMonadError)(dictMonadReader);
+    return dictLoadFile => Data$dFunctor.arrayMap(m => Data$dTuple.$Tuple(m._1, $$void(m._2)))(suite2(dictLoadFile)(Test$dSpecs$dParagraph.paragraph_cases)(Data$dTuple.$Tuple(
+      1,
+      false
+    )));
+  };
+};
+const linkingTests = dictMonadAff => {
+  const linkedOutputsSuite = Test$dUtil$dSuite.linkedOutputsSuite(dictMonadAff);
+  const linkedInputsSuite = Test$dUtil$dSuite.linkedInputsSuite(dictMonadAff);
+  return dictMonadError => {
+    const linkedOutputsSuite1 = linkedOutputsSuite(dictMonadError);
+    const linkedInputsSuite1 = linkedInputsSuite(dictMonadError);
+    return dictMonadReader => {
+      const linkedOutputsSuite2 = linkedOutputsSuite1(dictMonadReader);
+      const linkedInputsSuite2 = linkedInputsSuite1(dictMonadReader);
+      return dictLoadFile => [
+        ...linkedOutputsSuite2(dictLoadFile)(Test$dSpecs$dLinkedOutputs.linkedOutputs_cases),
+        ...linkedInputsSuite2(dictLoadFile)(Test$dSpecs$dLinkedInputs.linkedInputs_cases)
+      ];
+    };
+  };
+};
+const filterSuite = dictMonadAff => {
+  const $$void = dictMonadAff.MonadEffect0().Monad0().Bind1().Apply0().Functor0().map(v => {});
+  return dictMonadError => dictMonadReader => dictLoadFile => files => cases => makeSuite => Data$dFunctor.arrayMap(m => Data$dTuple.$Tuple(m._1, $$void(m._2)))(makeSuite(dictMonadError)(dictMonadReader)(dictLoadFile)(Data$dArray.filterImpl(
+    c => Data$dArray.elem(Data$dEq.eqString)(c.file)(files),
+    cases
+  ))(Data$dTuple.$Tuple(1, false)));
+};
+const benchmarks = dictMonadAff => {
+  const bwdSuite = Test$dUtil$dSuite.bwdSuite(dictMonadAff);
+  return dictMonadError => {
+    const bwdSuite1 = bwdSuite(dictMonadError);
+    return dictMonadReader => {
+      const suite2 = Test$dUtil$dSuite.suite(dictMonadAff)(dictMonadError)(dictMonadReader);
+      const bwdSuite2 = bwdSuite1(dictMonadReader);
+      return dictLoadFile => {
+        const suite3 = suite2(dictLoadFile);
+        return [
+          suite3(Test$dSpecs$dDesugar.desugar_cases),
+          suite3(Test$dSpecs$dMisc.misc_cases),
+          suite3(Test$dSpecs$dComments.comments_cases),
+          suite3(Test$dSpecs$dParagraph.paragraph_cases),
+          bwdSuite2(dictLoadFile)(Test$dSpecs$dBwd.bwd_cases),
+          suite3(Test$dSpecs$dGraphics.graphics_cases)
+        ];
+      };
+    };
+  };
+};
+const asTestSuite = dictMonadAff => {
+  const $$void = dictMonadAff.MonadEffect0().Monad0().Bind1().Apply0().Functor0().map(v => {});
+  return dictMonadError => dictLoadFile => suite => Data$dFunctor.arrayMap(m => Data$dTuple.$Tuple(m._1, $$void(m._2)))(suite(Data$dTuple.$Tuple(1, false)));
+};
+const allTests = dictMonadAff => {
+  const benchmarks1 = benchmarks(dictMonadAff);
+  const asTestSuite1 = asTestSuite(dictMonadAff);
+  const linkingTests1 = linkingTests(dictMonadAff);
+  return dictMonadError => {
+    const benchmarks2 = benchmarks1(dictMonadError);
+    const asTestSuite2 = asTestSuite1(dictMonadError);
+    const linkingTests2 = linkingTests1(dictMonadError);
+    return dictMonadReader => {
+      const benchmarks3 = benchmarks2(dictMonadReader);
+      const linkingTests3 = linkingTests2(dictMonadReader);
+      return dictLoadFile => [...Data$dArray.concat(Data$dFunctor.arrayMap(asTestSuite2(dictLoadFile))(benchmarks3(dictLoadFile))), ...linkingTests3(dictLoadFile)];
+    };
+  };
+};
+const main = () => {
+  for (
+    const $0 of Data$dFunctor.arrayMap(m => Data$dTuple.$Tuple(m._1, m._2({fluidSrcPaths: Test$dUtil.fluidSrcPaths})))(allTests(Effect$dAff$dClass.monadAffReader(Effect$dAff$dClass.monadAffAff))(Control$dMonad$dReader$dTrans.monadErrorReaderT(Effect$dAff.monadErrorAff))(Control$dMonad$dReader$dTrans.monadReaderReaderT(Effect$dAff.monadAff))({
+      loadFileFromPath: dictMonadError1 => dictMonadAff1 => x => {
+        const $1 = File.loadFileAff.loadFileFromPath(Effect$dAff.monadErrorAff)(Effect$dAff$dClass.monadAffAff)(x);
+        return v => $1;
+      }
+    }))
+  ) {
+    Test$dUtil$dMocha.executeTest($0)();
+  }
+};
+const tests = dictMonadAff => allTests(dictMonadAff);
+export {allTests, asTestSuite, benchmarks, filterSuite, linkingTests, main, scratchpad, tests};

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

@@ -0,0 +1,239 @@
+import * as $runtime from "../runtime.js";
+import * as App$dUtil from "../App.Util/index.js";
+import * as Control$dMonad$dWriter$dTrans from "../Control.Monad.Writer.Trans/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dHeytingAlgebra from "../Data.HeytingAlgebra/index.js";
+import * as Data$dList$dLazy from "../Data.List.Lazy/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCommon from "../Data.String.Common/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Desug from "../Desug/index.js";
+import * as Effect$dAff$dClass from "../Effect.Aff.Class/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Eval from "../Eval/index.js";
+import * as Expr from "../Expr/index.js";
+import * as File from "../File/index.js";
+import * as Graph$dGraphImpl from "../Graph.GraphImpl/index.js";
+import * as Lattice from "../Lattice/index.js";
+import * as Module from "../Module/index.js";
+import * as Parse from "../Parse/index.js";
+import * as Pretty from "../Pretty/index.js";
+import * as Pretty$dDoc from "../Pretty.Doc/index.js";
+import * as SExpr from "../SExpr/index.js";
+import * as Test$dBenchmark$dUtil from "../Test.Benchmark.Util/index.js";
+import * as Util from "../Util/index.js";
+import * as Val from "../Val/index.js";
+const eq = /* #__PURE__ */ (() => SExpr.eqExpr(Data$dEq.eqUnit).eq)();
+const boundedLattice = {BoundedJoinSemilattice0: () => Lattice.boundedJoinSemilatticeBoo, BoundedMeetSemilattice1: () => Lattice.boundedMeetSemilatticeBoo};
+const graphGC = /* #__PURE__ */ Eval.graphGC(Graph$dGraphImpl.graphGraphImpl);
+const graphGC1 = /* #__PURE__ */ graphGC(Val.applyEnvExpr)(Val.applyVal)(Val.foldableEnvExpr)(Val.foldableVal);
+const getPersistent = v => {
+  if (v.tag === "Inert") { return false; }
+  if (v.tag === "Reactive") { return v._1.persistent; }
+  $runtime.fail();
+};
+const prettyVal = /* #__PURE__ */ Pretty.prettyVal(Val.highlightableBoolean);
+const showPrettyShow = /* #__PURE__ */ (() => {
+  const $0 = Pretty.prettyExpr1(Val.highlightableBoolean);
+  return {show: v => Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)($0.pretty(v))._1};
+})();
+const greaterThanOrEq = /* #__PURE__ */ (() => {
+  const $0 = Expr.ordExpr(Data$dOrd.ordBoolean);
+  return a1 => a2 => $0.compare(a1)(a2) !== "LT";
+})();
+const showPrettyShow1 = {show: v => Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(prettyVal.pretty(v))._1};
+const greaterThanOrEq1 = /* #__PURE__ */ (() => {
+  const $0 = Val.ordVal(Data$dOrd.ordBoolean);
+  return a1 => a2 => $0.compare(a1)(a2) !== "LT";
+})();
+const dual = v => (
+  {
+    fwd: x => Val.functorEnvExpr.map(Data$dHeytingAlgebra.boolNot)(v.bwd(Val.functorVal.map(Data$dHeytingAlgebra.boolNot)(x))),
+    bwd: x => Val.functorVal.map(Data$dHeytingAlgebra.boolNot)(v.fwd(Val.functorEnvExpr.map(Data$dHeytingAlgebra.boolNot)(x)))
+  }
+);
+const graphGC2 = /* #__PURE__ */ graphGC(Val.applyVal)(Val.applyEnvExpr)(Val.foldableVal)(Val.foldableEnvExpr);
+const monadWriterT = /* #__PURE__ */ Control$dMonad$dWriter$dTrans.monadWriterT(Test$dBenchmark$dUtil.monoidBenchRow);
+const monadReaderWriterT = /* #__PURE__ */ Control$dMonad$dWriter$dTrans.monadReaderWriterT(Test$dBenchmark$dUtil.monoidBenchRow);
+const monadWriterWriterT = /* #__PURE__ */ Control$dMonad$dWriter$dTrans.monadWriterWriterT(Test$dBenchmark$dUtil.monoidBenchRow);
+const monadErrorWriterT = /* #__PURE__ */ Control$dMonad$dWriter$dTrans.monadErrorWriterT(Test$dBenchmark$dUtil.monoidBenchRow);
+const testPretty = dictAnn => {
+  const prettyP2 = Pretty.prettyP(Pretty.prettyExpr(dictAnn));
+  return dictShow => s => dictMonadAff => {
+    const MonadEffect0 = dictMonadAff.MonadEffect0();
+    const Monad0 = MonadEffect0.Monad0();
+    const Bind1 = Monad0.Bind1();
+    const $0 = MonadEffect0.Monad0().Applicative0();
+    const $1 = Monad0.Applicative0();
+    return dictMonadError => {
+      const throwLeft = Util.throwLeft(dictMonadError)(Data$dShow.showString);
+      const withMsg = Util.withMsg(dictMonadError);
+      const $$throw = Util.throw(dictMonadError.MonadThrow0());
+      return Bind1.bind($0.pure())(() => Bind1.bind($0.pure())(() => Bind1.bind(withMsg("testPretty")(throwLeft(Parse.parse(Parse.withImports(Parse.expr))(prettyP2(s)))))(v => {
+        const $2 = eq(SExpr.functorExpr.map(v$1 => {})(s))(SExpr.functorExpr.map(v$1 => {})(v._1));
+        const $3 = $$throw("parse/prettyP round trip:\nOriginal\n" + Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(Pretty.prettyExpr(Val.annUnit).pretty(SExpr.functorExpr.map(v$1 => {})(s)))._1 + "\nNew\n" + Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(Pretty.prettyExpr(Val.annUnit).pretty(SExpr.functorExpr.map(v$1 => {})(v._1)))._1);
+        if (!$2) { return $3; }
+        if ($2) { return $1.pure(); }
+        $runtime.fail();
+      })));
+    };
+  };
+};
+const testPretty1 = /* #__PURE__ */ testPretty(Val.annUnit)(Data$dShow.showUnit);
+const testOutcome = b => s => (b ? "\u001b[32m " : "\u001b[31m ") + (b ? "✔" : "✖") + "\u001b[0m " + s;
+const testCondition = dictMonadThrow => dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const $0 = Monad0.Applicative0();
+  return testName => b => msg => Monad0.Bind1().bind(dictMonadEffect.liftEffect(Effect$dConsole.log((b ? "\u001b[32m " : "\u001b[31m ") + (b ? "✔" : "✖") + "\u001b[0m " + testName + ": " + msg)))(() => {
+    const $1 = dictMonadThrow.throwError(Effect$dException.error("Test failed"));
+    if (!b) { return $1; }
+    return $0.pure();
+  });
+};
+const graphBenchmark = dictMonadWriter => name => Test$dBenchmark$dUtil.benchmark(dictMonadWriter)("G-" + name);
+const fluidSrcPaths = ["fluid", "test/fluid"];
+const checkPretty = dictPretty => expect => x => dictMonadEffect => {
+  const $0 = dictMonadEffect.Monad0().Applicative0();
+  return dictMonadError => {
+    const $1 = Data$dString$dCommon.trim(expect) === Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(dictPretty.pretty(x))._1;
+    const $2 = dictMonadError.MonadThrow0().throwError(Effect$dException.error("checkPretty:\nExpected\n" + expect + "\nReceived\n" + Pretty$dDoc.renderWithIndent(Pretty$dDoc.Stmt)(0)(0)(dictPretty.pretty(x))._1));
+    if (!$1) { return $2; }
+    if ($1) { return $0.pure(); }
+    $runtime.fail();
+  };
+};
+const checkEq = dictBotOf => dictNeg => dictMeetSemilattice => dictEq => dictPretty => dictMonadError => {
+  const MonadThrow0 = dictMonadError.MonadThrow0();
+  return op1 => op2 => x => y => {
+    const v = Pretty.compare(dictBotOf)(dictNeg)(dictMeetSemilattice)(dictEq)(dictPretty)(op1)(op2)(x)(y);
+    const $0 = v._2;
+    return MonadThrow0.Monad0().Bind1().bind(Util.check(MonadThrow0)(v._1 === "")(v._1))(() => Util.check(MonadThrow0)($0 === "")($0));
+  };
+};
+const benchNames = {eval: "Eval", bwd: "Demands", demBy: "DemBy", fwd: "Suffices", demBy_G_direct: "DemBy-Dir", demBy_G_suff_dual: "DemBy-Suff"};
+const testProperties = dictMonadReader => dictLoadFile => dictMonadWriter => s => gconfig => v => dictMonadAff => {
+  const MonadEffect0 = dictMonadAff.MonadEffect0();
+  const Monad0 = MonadEffect0.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const graphEval = Eval.graphEval(dictMonadAff)(dictMonadReader)(dictLoadFile);
+  const Applicative0 = Monad0.Applicative0();
+  return dictMonadError => {
+    const graphEval1 = graphEval(dictMonadError);
+    const checkSatisfies = Util.checkSatisfies(dictMonadError.MonadThrow0());
+    const checkSatisfies1 = checkSatisfies(showPrettyShow);
+    const checkSatisfies2 = checkSatisfies(showPrettyShow1);
+    const withMsg = Util.withMsg(dictMonadError);
+    const $0 = v.bwd_expect;
+    const $1 = v.fwd_expect;
+    return Bind1.bind(Desug.desugGC(dictMonadError)(Data$dEq.eqBoolean)(boundedLattice)(s))(v1 => {
+      const $2 = v1.gc;
+      const $3 = v1.e;
+      return Bind1.bind(Test$dBenchmark$dUtil.benchmark$p(dictMonadWriter)("G-Eval")(v2 => graphEval1(gconfig)($3))(MonadEffect0)(dictMonadError))(v2 => {
+        const $4 = v2.g;
+        const $5 = graphGC1(v2);
+        const $6 = {fwd: x => $5.fwd(x)._1, bwd: x => $5.bwd(x)._1};
+        const out0 = Val.functorVal.map(getPersistent)(v["δv"](Val.functorVal.map(v$1 => App$dUtil.unselected)(Val.functorVal.map(v$1 => true)(v2["outα"])))._1);
+        return Bind1.bind(Test$dBenchmark$dUtil.benchmark$p(dictMonadWriter)("G-Demands")(v5 => Applicative0.pure($6.bwd(Util.spyWhen(false)("Selection for bwd")(Pretty.prettyP(prettyVal))(out0))))(MonadEffect0)(dictMonadError))(v5 => {
+          const $7 = v5._2;
+          const $8 = v5._1;
+          const in_s = $2.bwd($7);
+          return Bind1.bind((() => {
+            const in_e$p = $2.fwd(in_s);
+            return Bind1.bind(checkSatisfies1("fwd ⚬ bwd round-trip (desugar)")(in_e$p)(x => greaterThanOrEq(x)($7)))(() => Test$dBenchmark$dUtil.benchmark$p(dictMonadWriter)("G-Suffices")(v6 => Applicative0.pure($6.fwd(Val.$EnvExpr(
+              $8,
+              in_e$p
+            ))))(MonadEffect0)(dictMonadError));
+          })())(out1 => Bind1.bind(checkSatisfies2("fwd ⚬ bwd round-trip (eval)")(out1)(x => greaterThanOrEq1(x)(out0)))(() => Bind1.bind((() => {
+            const $9 = $0 === "";
+            const $10 = withMsg("bwd_expect")(checkPretty(Pretty.prettyExpr(Val.annBoolean))($0)(in_s)(MonadEffect0)(dictMonadError));
+            if (!$9) { return $10; }
+            if ($9) { return Applicative0.pure(); }
+            $runtime.fail();
+          })())(() => Bind1.bind((() => {
+            const $9 = $1 === "";
+            const $10 = withMsg("fwd_expect")(checkPretty(prettyVal)($1)(Util.spyWhen(false)("fwd ⚬ bwd")(Pretty.prettyP(prettyVal))(out1))(MonadEffect0)(dictMonadError));
+            if (!$9) { return $10; }
+            if ($9) { return Applicative0.pure(); }
+            $runtime.fail();
+          })())(() => Bind1.bind(Test$dBenchmark$dUtil.recordGraphSize(Graph$dGraphImpl.graphGraphImpl)(dictMonadWriter)($4))(() => Bind1.bind(Applicative0.pure())(() => {
+            const $9 = dual($6);
+            const $10 = graphGC2({
+              g: Graph$dGraphImpl.$GraphImpl({out: v2.g._1.in_, in_: v2.g._1.out, sinks: v2.g._1.sources, sources: v2.g._1.sinks, vertices: v2.g._1.vertices}),
+              graph_fwd: v2.graph_fwd,
+              graph_bwd: v2.graph_bwd,
+              "inα": v2["outα"],
+              "outα": v2["inα"]
+            });
+            return Bind1.bind(Test$dBenchmark$dUtil.benchmark$p(dictMonadWriter)("G-DemBy-Dir")(v8 => Applicative0.pure($10.bwd(v5)._1))(MonadEffect0)(dictMonadError))(out2 => Bind1.bind(Test$dBenchmark$dUtil.benchmark$p(dictMonadWriter)("G-DemBy-Suff")(v8 => Applicative0.pure($9.bwd(v5)))(MonadEffect0)(dictMonadError))(out3 => Applicative0.pure()));
+          }))))));
+        });
+      });
+    });
+  };
+};
+const test = dictMonadReader => {
+  const testProperties1 = testProperties(monadReaderWriterT(dictMonadReader));
+  return dictLoadFile => file => primitives => spec => v => dictMonadAff => {
+    const MonadEffect0 = dictMonadAff.MonadEffect0();
+    const Monad0 = MonadEffect0.Monad0();
+    const Bind1 = Monad0.Bind1();
+    const loadFile1 = File.loadFile(dictLoadFile)(Monad0);
+    const $0 = MonadEffect0.Monad0().Applicative0();
+    const prepConfig = Module.prepConfig(dictMonadAff);
+    const replicateM = Data$dList$dLazy.replicateM(monadWriterT(Monad0));
+    const monadWriterWriterT1 = monadWriterWriterT(Monad0);
+    const monadAffWriter = Effect$dAff$dClass.monadAffWriter(dictMonadAff)(Test$dBenchmark$dUtil.monoidBenchRow);
+    return dictMonadError => {
+      const prepConfig1 = prepConfig(dictMonadError)(dictMonadReader)(dictLoadFile);
+      const testProperties2 = testProperties1((() => {
+        const $1 = dictMonadAff.MonadEffect0().Monad0();
+        const loadFileFromPath1 = dictLoadFile.loadFileFromPath(dictMonadError)(dictMonadAff);
+        return {
+          loadFileFromPath: dictMonadError1 => dictMonadAff1 => x => $1.Bind1().bind(loadFileFromPath1(x))(a => $1.Applicative0().pure(Data$dTuple.$Tuple(
+            a,
+            Data$dMap$dInternal.Leaf
+          )))
+        };
+      })())(monadWriterWriterT1);
+      const monadErrorWriterT1 = monadErrorWriterT(dictMonadError);
+      const $1 = v._1;
+      return Bind1.bind(loadFile1(dictMonadError)(dictMonadAff)(fluidSrcPaths)(file))(fluidSrc => Bind1.bind($0.pure())(() => Bind1.bind(prepConfig1(primitives)(fluidSrc))(v1 => {
+        const $2 = v1.gconfig;
+        const $3 = v1.s;
+        return Bind1.bind(testPretty1($3)(dictMonadAff)(dictMonadError))(() => Bind1.bind(replicateM($1)(testProperties2($3)($2)(spec)(monadAffWriter)(monadErrorWriterT1)))(v2 => Monad0.Applicative0().pure(Test$dBenchmark$dUtil.divRow(v2._2)($1))));
+      })));
+    };
+  };
+};
+export {
+  benchNames,
+  boundedLattice,
+  checkEq,
+  checkPretty,
+  dual,
+  eq,
+  fluidSrcPaths,
+  getPersistent,
+  graphBenchmark,
+  graphGC,
+  graphGC1,
+  graphGC2,
+  greaterThanOrEq,
+  greaterThanOrEq1,
+  monadErrorWriterT,
+  monadReaderWriterT,
+  monadWriterT,
+  monadWriterWriterT,
+  prettyVal,
+  showPrettyShow,
+  showPrettyShow1,
+  test,
+  testCondition,
+  testOutcome,
+  testPretty,
+  testPretty1,
+  testProperties
+};

package/output-es/Test.Util.Debug/index.js

@@ -0,0 +1,6 @@
+import * as Test$dUtil$dDebug$dDefaults from "../Test.Util.Debug.Defaults/index.js";
+const tracing = Test$dUtil$dDebug$dDefaults.tracingDefaults;
+const timing = Test$dUtil$dDebug$dDefaults.timingDefaults;
+const testing = Test$dUtil$dDebug$dDefaults.testingDefaults;
+const checking = Test$dUtil$dDebug$dDefaults.checkingDefaults;
+export {checking, testing, timing, tracing};

package/output-es/Test.Util.Debug.Defaults/index.js

@@ -0,0 +1,16 @@
+const tracingDefaults = {
+  runWithGraphT: false,
+  graphBwdSlice: false,
+  graphBwdSlice_vertexData: false,
+  graphFwdSlice: false,
+  checkEq: false,
+  bwdSelection: false,
+  fwdAfterBwd: false,
+  mediatingData: false,
+  mouseEvent: false,
+  intermediates: true
+};
+const timingDefaults = {selectionResult: false};
+const testingDefaults = {fwdPreservesTop: false, bwdDuals: false, fwdDuals: false, naiveFwd: false};
+const checkingDefaults = {edgeListGC: false, edgeListSorted: false, inputsAreSinks: false, outputsInGraph: false, allocRoundTrip: false, mustEq: false};
+export {checkingDefaults, testingDefaults, timingDefaults, tracingDefaults};

package/output-es/Test.Util.Mocha/foreign.js

@@ -0,0 +1,55 @@
+/* global exports, it, describe */
+
+// module Test.Spec.Mocha2
+
+if (typeof describe !== 'function' || typeof it !== 'function') {
+    throw new Error('Mocha globals seem to be unavailable!');
+}
+
+/*
+    only :: Boolean
+    name :: String
+    run  :: (Effect Unit -> (Error -> Effect Unit) -> Effect Unit)
+    done 
+
+*/
+export function itAsync(only) {
+    "use strict";
+    return function (name) {
+        return function (run) {
+            return function () {
+                var f = only ? it.only : it;
+                f(name, function (done) {     // f :: String -> 
+                    return run(function () {
+                        done();
+                        return function () {};
+                    })(function (err) {
+                        done(err);
+                        return function () {};
+                    })();
+                });
+            };
+        };
+    };
+}
+
+export function itPending(name) {
+    "use strict";
+    return function () {
+        it(name);
+    };
+}
+
+export function describe(only) {
+    "use strict";
+    return function (name) {
+        return function (nested) {
+            return function () {
+                var f = only ? describe.only : describe;
+                f(name, function () {
+                    nested();
+                });
+            };
+        };
+    };
+}

package/output-es/Test.Util.Mocha/index.js

@@ -0,0 +1,21 @@
+import * as $runtime from "../runtime.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import {describe, itAsync, itPending} from "./foreign.js";
+const executeTest = v => {
+  const $0 = v._2;
+  return itAsync(true)(v._1)(onSuccess => onError => {
+    const $1 = Effect$dAff.runAff(v2 => {
+      if (v2.tag === "Left") { return onError(v2._1); }
+      if (v2.tag === "Right") { return onSuccess; }
+      $runtime.fail();
+    })($0);
+    return () => {$1();};
+  });
+};
+const run = a => () => {
+  for (const $0 of a) {
+    executeTest($0)();
+  }
+};
+export {executeTest, run};
+export * from "./foreign.js";

package/output-es/Test.Util.Puppeteer/index.js

@@ -0,0 +1,83 @@
+import * as Control$dPromise from "../Control.Promise/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Test$dUtil from "../Test.Util/index.js";
+import * as Toppokki from "../Toppokki/index.js";
+import {_launch} from "./foreign.js";
+const sequence_ = /* #__PURE__ */ Data$dFoldable.traverse_(Effect$dAff.applicativeAff)(Data$dFoldable.foldableArray)(Data$dFoldable.identity);
+const testCondition = /* #__PURE__ */ Test$dUtil.testCondition(Effect$dAff.monadThrowAff)(Effect$dAff.monadEffectAff);
+const for_ = /* #__PURE__ */ Data$dFoldable.for_(Effect$dAff.applicativeAff)(Data$dFoldable.foldableArray);
+const timeout = 60000;
+const textContentValue = page => selector => Effect$dAff._bind(Toppokki.runPromiseAffE3(Toppokki._unsafePageEval)(selector)("element => element.textContent")(page))(captionText => Effect$dAff._pure(captionText));
+const show$p = v => v;
+const runTests = arr => Control$dPromise.fromAff(sequence_(arr));
+const puppeteerTests = {logging: true, headless: true};
+const log$p = dictMonadEffect => x => dictMonadEffect.liftEffect(Effect$dConsole.log(x));
+const waitFor = selector => page => {
+  const report = testCondition(selector);
+  return Effect$dAff._bind(Effect$dAff._liftEffect(Effect$dConsole.log("Waiting for " + selector)))(() => Effect$dAff._catchError(Effect$dAff._bind(Effect$dAff._map(v => {})(Toppokki.runPromiseAffE3(Toppokki._pageWaitForSelector)(selector)({
+    timeout: 60000,
+    visible: true
+  })(page)))(() => Effect$dAff._bind(Effect$dAff._liftEffect(Effect$dConsole.log("-> found")))(() => report(true)("exists"))))(e => report(false)(Effect$dException.showErrorImpl(e))));
+};
+const waitForHidden = selector => page => Effect$dAff._bind(Effect$dAff._liftEffect(Effect$dConsole.log("Waiting for " + selector)))(() => Effect$dAff._bind(Effect$dAff._map(v => {})(Toppokki.runPromiseAffE3(Toppokki._pageWaitForSelector)(selector)({
+  timeout: 60000,
+  visible: false
+})(page)))(() => Effect$dAff._liftEffect(Effect$dConsole.log("-> found"))));
+const launch = /* #__PURE__ */ Toppokki.runPromiseAffE1(_launch);
+const $$goto = v => page => Effect$dAff._bind(Effect$dAff._liftEffect(Effect$dConsole.log("Going to " + Data$dShow.showStringImpl(v))))(() => Effect$dAff._bind(Effect$dAff._liftEffect(Toppokki._goto(
+  v,
+  page
+)))(Control$dPromise.toAff$p(Control$dPromise.coerce)));
+const getAttributeValue = page => selector => attribute => Effect$dAff._bind(Toppokki.runPromiseAffE3(Toppokki._unsafePageEval)(selector)("element => element.getAttribute('" + attribute + "')")(page))(attrValue => Effect$dAff._pure(attrValue));
+const defaultViewport = {deviceScaleFactor: 1.0, hasTouch: false, height: 800.0, isLandscape: false, isMobile: false, width: 1200.0};
+const click = element => page => Effect$dAff._bind(Effect$dAff._bind(Effect$dAff._liftEffect(Toppokki._click(element, page)))(Control$dPromise.toAff$p(Control$dPromise.coerce)))(() => testCondition(element)(true)("click"));
+const clickToggle = page => idPrev => Effect$dAff._bind(waitFor("#grid.data-pane-hidden")(page))(() => {
+  const toggle = "div#" + idPrev + " + div";
+  return Effect$dAff._bind(waitFor(toggle)(page))(() => Effect$dAff._bind(click(toggle)(page))(() => waitFor("#grid:not(.data-pane-hidden)")(page)));
+});
+const checkTextContent = page => selector => expected => Effect$dAff._bind(waitFor(selector)(page))(() => Effect$dAff._bind(textContentValue(page)(selector))(text => Effect$dAff._bind(testCondition(selector)(text === expected)("text == " + Data$dShow.showStringImpl(expected)))(() => Effect$dAff._pure())));
+const checkAttributeContains = page => sel => attr => expected => Effect$dAff._bind(getAttributeValue(page)(sel)(attr))(found => {
+  const success = Data$dString$dCodeUnits.contains(expected)(found);
+  return testCondition(sel)(success)(attr + " contains " + Data$dShow.showStringImpl(expected) + (success ? "" : " (got " + found + ")"));
+});
+const checkAttribute = page => sel => attr => expected => Effect$dAff._bind(getAttributeValue(page)(sel)(attr))(found => testCondition(sel)(found === expected)(attr + " == " + Data$dShow.showStringImpl(expected) + (found === expected
+  ? ""
+  : " (got \"" + found + "\")")));
+const browserTests = suffix => browserName => launchBrowser => tests => Effect$dAff._bind(Effect$dAff._liftEffect(Effect$dConsole.log("browserTests: " + browserName)))(() => Effect$dAff._bind(launchBrowser)(browser => Effect$dAff._bind(Effect$dAff._bind(Effect$dAff._liftEffect(Toppokki._newPage(browser)))(Control$dPromise.toAff$p(Control$dPromise.coerce)))(page => {
+  const url = "http://127.0.0.1:8080/" + suffix;
+  return Effect$dAff._bind(for_(tests)(test => Effect$dAff._bind($$goto(url)(page))(() => test(page))))(() => Effect$dAff._bind(Effect$dAff._liftEffect(Toppokki._close(browser)))(Control$dPromise.toAff$p(Control$dPromise.coerce)));
+})));
+const testURL = suffix => tests => {
+  const testOn = browser => browserTests(suffix)(browser)(Effect$dAff._bind(Effect$dAff._liftEffect(_launch({browser, defaultViewport, headless: true})))(Control$dPromise.toAff$p(Control$dPromise.coerce)))(tests);
+  return [testOn("chrome"), testOn("firefox")];
+};
+export {
+  browserTests,
+  checkAttribute,
+  checkAttributeContains,
+  checkTextContent,
+  click,
+  clickToggle,
+  defaultViewport,
+  for_,
+  getAttributeValue,
+  $$goto as goto,
+  launch,
+  log$p,
+  puppeteerTests,
+  runTests,
+  sequence_,
+  show$p,
+  testCondition,
+  testURL,
+  textContentValue,
+  timeout,
+  waitFor,
+  waitForHidden
+};
+export * from "./foreign.js";