@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,270 @@
+// | This module defines the random generator monad used by the `Test.QuickCheck`
+// | module, as well as helper functions for constructing random generators.
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dArray$dNonEmpty$dInternal from "../Data.Array.NonEmpty.Internal/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dIdentity from "../Data.Identity/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$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNumber from "../Data.Number/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Data$dUnfoldable from "../Data.Unfoldable/index.js";
+import * as Random$dLCG from "../Random.LCG/index.js";
+import {float32ToInt32} from "./foreign.js";
+const monadStateStateT = /* #__PURE__ */ Control$dMonad$dState$dTrans.monadStateStateT(Data$dIdentity.monadIdentity);
+const bindStateT = /* #__PURE__ */ Control$dMonad$dState$dTrans.bindStateT(Data$dIdentity.monadIdentity);
+const functorStateT = {
+  map: f => v => s => {
+    const $0 = v(s);
+    return Data$dTuple.$Tuple(f($0._1), $0._2);
+  }
+};
+const toUnfoldable = /* #__PURE__ */ (() => Data$dUnfoldable.unfoldableArray.unfoldr(xs => {
+  if (xs.tag === "Nil") { return Data$dMaybe.Nothing; }
+  if (xs.tag === "Cons") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(xs._1, xs._2)); }
+  $runtime.fail();
+}))();
+const min = x => y => {
+  const v = Data$dOrd.ordNumber.compare(x)(y);
+  if (v === "LT") { return x; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return y; }
+  $runtime.fail();
+};
+const max = x => y => {
+  const v = Data$dOrd.ordNumber.compare(x)(y);
+  if (v === "LT") { return y; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return x; }
+  $runtime.fail();
+};
+const foldMap1 = /* #__PURE__ */ (() => Data$dArray$dNonEmpty$dInternal.foldable1NonEmptyArray.foldMap1({append: v => v1 => v + v1}))();
+const unGen = v => v;
+const runGen = x => x$1 => x(x$1);
+const stateful = f => monadStateStateT.state(s => f(s)(s));
+const sized = f => monadStateStateT.state(s => f(s.size)(s));
+const variant = n => g => monadStateStateT.state(s => g({newSeed: n, size: s.size}));
+const resize = sz => g => monadStateStateT.state(v => {
+  const $0 = g({newSeed: v.newSeed, size: sz});
+  return Data$dTuple.$Tuple($0._1, {size: v.size, newSeed: $0._2.newSeed});
+});
+const replicateMRec = dictMonadRec => {
+  const Monad0 = dictMonadRec.Monad0();
+  const $0 = Monad0.Applicative0();
+  const $1 = Monad0.Bind1().Apply0().Functor0();
+  return v => v1 => {
+    if (v <= 0) { return $0.pure(Data$dList$dTypes.Nil); }
+    return dictMonadRec.tailRecM(v2 => {
+      if (v2._2 === 0) { return $0.pure(Control$dMonad$dRec$dClass.$Step("Done", v2._1)); }
+      const $2 = v2._1;
+      const $3 = v2._2;
+      return $1.map(x => Control$dMonad$dRec$dClass.$Step("Loop", Data$dTuple.$Tuple(Data$dList$dTypes.$List("Cons", x, $2), $3 - 1 | 0)))(v1);
+    })(Data$dTuple.$Tuple(Data$dList$dTypes.Nil, v));
+  };
+};
+const repeatable = f => monadStateStateT.state(s => Data$dTuple.$Tuple(a => f(a)(s)._1, {newSeed: Random$dLCG.lcgPerturb(0)(s.newSeed), size: s.size}));
+const perturbGen = n => gen => bindStateT.bind((() => {
+  const $0 = monadStateStateT.state(s => {
+    const s$p = {...s, newSeed: Random$dLCG.lcgPerturb(float32ToInt32(n))(s.newSeed)};
+    return Data$dTuple.$Tuple(s$p, s$p);
+  });
+  return s => Data$dTuple.$Tuple(undefined, $0(s)._2);
+})())(() => gen);
+const monadRecGen = /* #__PURE__ */ Control$dMonad$dState$dTrans.monadRecStateT(Control$dMonad$dRec$dClass.monadRecIdentity);
+const monadGen = {
+  Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT(Data$dIdentity.monadIdentity),
+  Bind1: () => Control$dMonad$dState$dTrans.bindStateT(Data$dIdentity.monadIdentity)
+};
+const listOf = /* #__PURE__ */ replicateMRec(monadRecGen);
+const lcgStep = /* #__PURE__ */ (() => monadStateStateT.state(s => Data$dTuple.$Tuple(s.newSeed, {...s, newSeed: Random$dLCG.lcgPerturb(0)(s.newSeed)})))();
+const lazyGen = Control$dMonad$dState$dTrans.lazyStateT;
+const functorGen = functorStateT;
+const uniform = s => {
+  const $0 = lcgStep(s);
+  return Data$dTuple.$Tuple(Data$dInt.toNumber($0._1) / Data$dInt.toNumber(2147483647), $0._2);
+};
+const vectorOf = k => g => {
+  const $0 = listOf(k)(g);
+  return s => {
+    const $1 = $0(s);
+    return Data$dTuple.$Tuple(toUnfoldable($1._1), $1._2);
+  };
+};
+const evalGen = x => s => x(s)._1;
+const randomSampleOne = gen => () => {
+  const seed = Random$dLCG.randomSeed();
+  return gen({newSeed: seed, size: 10})._1;
+};
+const sample = seed => sz => g => vectorOf(sz)(g)({newSeed: seed, size: sz})._1;
+const randomSample$p = n => g => () => {
+  const seed = Random$dLCG.randomSeed();
+  return vectorOf(n)(g)({newSeed: seed, size: n})._1;
+};
+const randomSample = /* #__PURE__ */ randomSample$p(10);
+const choose = a => b => {
+  const min$p = min(a)(b) * 0.5;
+  const $0 = max(a)(b) * 0.5 - min$p;
+  return s => {
+    const $1 = uniform(s);
+    return Data$dTuple.$Tuple((min$p + $0 * $1._1) * 2.0, $1._2);
+  };
+};
+const bindGen = bindStateT;
+const frequency = xxs => {
+  const $$default = (() => {
+    if (0 < xxs.length) { return xxs[0]._2; }
+    $runtime.fail();
+  })();
+  const pick = pick$a0$copy => pick$a1$copy => {
+    let pick$a0 = pick$a0$copy, pick$a1 = pick$a1$copy, pick$c = true, pick$r;
+    while (pick$c) {
+      const i = pick$a0, n = pick$a1;
+      if (i >= 0 && i < xxs.length) {
+        if (n <= xxs[i]._1) {
+          pick$c = false;
+          pick$r = xxs[i]._2;
+          continue;
+        }
+        pick$a0 = i + 1 | 0;
+        pick$a1 = n - xxs[i]._1;
+        continue;
+      }
+      pick$c = false;
+      pick$r = $$default;
+    }
+    return pick$r;
+  };
+  return bindStateT.bind(choose(0.0)(foldMap1(x => x._1)(xxs)))(n => pick(0)(n));
+};
+const applyGen = /* #__PURE__ */ Control$dMonad$dState$dTrans.applyStateT(Data$dIdentity.monadIdentity);
+const chooseInt$p = a => b => {
+  const numB = Data$dInt.toNumber(b);
+  const numA = Data$dInt.toNumber(a);
+  const $0 = applyGen.apply(s => {
+    const $0 = lcgStep(s);
+    const $1 = Data$dInt.toNumber($0._1);
+    return Data$dTuple.$Tuple($2 => $1 + $2, $0._2);
+  })(s => {
+    const $0 = lcgStep(s);
+    return Data$dTuple.$Tuple(2.0 * Data$dInt.toNumber($0._1), $0._2);
+  });
+  return s => {
+    const $1 = $0(s);
+    return Data$dTuple.$Tuple(Data$dInt.unsafeClamp(Data$dNumber.floor(numA + Data$dNumber.remainder($1._1)(numB - numA + 1.0))), $1._2);
+  };
+};
+const chooseInt = a => b => {
+  if (a <= b) { return chooseInt$p(a)(b); }
+  return chooseInt$p(b)(a);
+};
+const arrayOf = g => monadStateStateT.state(s => bindStateT.bind(0 <= s.size ? chooseInt$p(0)(s.size) : chooseInt$p(s.size)(0))(k => vectorOf(k)(g))(s));
+const monadGenGen = {
+  chooseInt,
+  chooseFloat: choose,
+  chooseBool: s => {
+    const $0 = uniform(s);
+    return Data$dTuple.$Tuple($0._1 < 0.5, $0._2);
+  },
+  resize: f => g => monadStateStateT.state(s => resize(f(s.size))(g)(s)),
+  sized,
+  Monad0: () => monadGen
+};
+const oneOf = xs => bindStateT.bind((() => {
+  const $0 = xs.length - 1 | 0;
+  if (0 <= $0) { return chooseInt$p(0)($0); }
+  return chooseInt$p($0)(0);
+})())(n => xs[n]);
+const applicativeGen = /* #__PURE__ */ Control$dMonad$dState$dTrans.applicativeStateT(Data$dIdentity.monadIdentity);
+const arrayOf1 = g => monadStateStateT.state(s => bindStateT.bind(0 <= s.size ? chooseInt$p(0)(s.size) : chooseInt$p(s.size)(0))(k => bindStateT.bind(g)(x => bindStateT.bind(vectorOf(k - 1 | 0)(g))(xs => applicativeGen.pure((() => {
+  const $0 = [x, ...xs];
+  if ($0.length > 0) { return $0; }
+  $runtime.fail();
+})()))))(s));
+const elements = xs => bindStateT.bind((() => {
+  const $0 = xs.length - 1 | 0;
+  if (0 <= $0) { return chooseInt$p(0)($0); }
+  return chooseInt$p($0)(0);
+})())(n => applicativeGen.pure(xs[n]));
+const $$enum = dictBoundedEnum => {
+  const Bounded0 = dictBoundedEnum.Bounded0();
+  return bindStateT.bind((() => {
+    const $0 = dictBoundedEnum.fromEnum(Bounded0.bottom);
+    const $1 = dictBoundedEnum.fromEnum(Bounded0.top);
+    if ($0 <= $1) { return chooseInt$p($0)($1); }
+    return chooseInt$p($1)($0);
+  })())(i => applicativeGen.pure((() => {
+    const $0 = dictBoundedEnum.toEnum(i);
+    if ($0.tag === "Just") { return $0._1; }
+    $runtime.fail();
+  })()));
+};
+const shuffle = xs => bindStateT.bind(vectorOf(xs.length)(chooseInt$p(0)(2147483647)))(ns => applicativeGen.pure(Data$dFunctor.arrayMap(Data$dTuple.snd)(Data$dArray.sortBy(x => y => Data$dOrd.ordInt.compare(x._1)(y._1))(Data$dArray.zipWithImpl(
+  Data$dTuple.Tuple,
+  ns,
+  xs
+)))));
+const suchThat = gen => pred => monadRecGen.tailRecM(v => bindStateT.bind(gen)(a => applicativeGen.pure(pred(a)
+  ? Control$dMonad$dRec$dClass.$Step("Done", a)
+  : Control$dMonad$dRec$dClass.$Step("Loop", undefined))))();
+const altGen = /* #__PURE__ */ (() => {
+  const functorStateT1 = {
+    map: f => v => s => {
+      const $0 = v(s);
+      return Data$dTuple.$Tuple(f($0._1), $0._2);
+    }
+  };
+  return {alt: v => v1 => s => v(s), Functor0: () => functorStateT1};
+})();
+export {
+  altGen,
+  applicativeGen,
+  applyGen,
+  arrayOf,
+  arrayOf1,
+  bindGen,
+  bindStateT,
+  choose,
+  chooseInt,
+  chooseInt$p,
+  elements,
+  $$enum as enum,
+  evalGen,
+  foldMap1,
+  frequency,
+  functorGen,
+  functorStateT,
+  lazyGen,
+  lcgStep,
+  listOf,
+  max,
+  min,
+  monadGen,
+  monadGenGen,
+  monadRecGen,
+  monadStateStateT,
+  oneOf,
+  perturbGen,
+  randomSample,
+  randomSample$p,
+  randomSampleOne,
+  repeatable,
+  replicateMRec,
+  resize,
+  runGen,
+  sample,
+  shuffle,
+  sized,
+  stateful,
+  suchThat,
+  toUnfoldable,
+  unGen,
+  uniform,
+  variant,
+  vectorOf
+};
+export * from "./foreign.js";

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

@@ -0,0 +1,220 @@
+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$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 select$p = x => Data$dTuple.$Tuple(!x, App$dUtil.Persistent);
+const bwd_cases = [
+  {file: "add.fld", bwd_expect_file: "add.expect.fld", "δv": select, fwd_expect: "⸨8⸩"},
+  {file: "array/lookup.fld", bwd_expect_file: "array/lookup.expect.fld", "δv": select, fwd_expect: "⸨14⸩"},
+  {file: "array/dims.fld", bwd_expect_file: "array/dims.expect.fld", "δv": select, fwd_expect: "⸨(⸨3⸩, ⸨3⸩)⸩"},
+  {
+    file: "convolution/edgeDetect.fld",
+    bwd_expect_file: "convolution/edgeDetect.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.matrixElement(0)(0)(select),
+    fwd_expect: "⸨0⸩, -1, 2, 0, -1,\n0, 3, -2, 3, -2,\n-1, 1, -5, 0, 4,\n1, -1, 4, 0, -4,\n1, 0, -3, 2, 0"
+  },
+  {
+    file: "convolution/emboss.fld",
+    bwd_expect_file: "convolution/emboss.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.matrixElement(0)(0)(select),
+    fwd_expect: "⸨5⸩, 4, 2, 5, 2,\n3, 1, 2, -1, -2,\n3, 0, 1, 0, -1,\n2, 1, -2, 0, 0,\n1, 0, -1, -1, -2"
+  },
+  {
+    file: "convolution/gaussian.fld",
+    bwd_expect_file: "convolution/gaussian.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.matrixElement(0)(0)(select),
+    fwd_expect: "⸨38⸩, 37, 28, 30, 38,\n38, 36, 46, 31, 34,\n37, 41, 54, 34, 20,\n21, 35, 31, 31, 42,\n13, 32, 35, 19, 26"
+  },
+  {
+    file: "matrix/matmul.fld",
+    bwd_expect_file: "matrix/matmul.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.constrArg("Pair")(0)(/* #__PURE__ */ App$dUtil$dSelector.matrixElement(0)(0)(select)),
+    fwd_expect: "(@doc(Paragraph(\"Intermediate\" :| \"matrix\" :| [])) ⸨22⸩, 28,\n49, 64, @doc(Paragraph(\"Intermediate\" :| \"matrix\" :| [])) 9, 12, 15,\n19, 26, 33,\n29, 40, 51)"
+  },
+  {file: "dict/create.fld", bwd_expect_file: "dict/create.expect.fld", "δv": /* #__PURE__ */ App$dUtil$dSelector.dictKey("ab")(select$p), fwd_expect: "{ a: 5, ⸨ab⸩: 6 }"},
+  {
+    file: "dict/difference.fld",
+    bwd_expect_file: "dict/difference.expect.fld",
+    "δv": v => {
+      if (v._3.tag === "Dictionary") {
+        return Data$dTuple.$Tuple(
+          Val.$Val(
+            (() => {
+              if (v._1.tag === "Inert") { return App$dUtil.Inert; }
+              if (v._1.tag === "Reactive") { return App$dUtil.$SelState("Reactive", {persistent: !v._1._1.persistent, transient: v._1._1.transient}); }
+              $runtime.fail();
+            })(),
+            v._2,
+            Val.$BaseVal("Dictionary", v._3._1)
+          ),
+          App$dUtil.Persistent
+        );
+      }
+      $runtime.fail();
+    },
+    fwd_expect: "⸨{ a: 5 }⸩"
+  },
+  {
+    file: "dict/disjointUnion.fld",
+    bwd_expect_file: "dict/disjointUnion.expect.fld",
+    "δv": x => App$dUtil$dSelector.dictVal("c")(select)(App$dUtil$dSelector.dictKey("a")(select$p)(x)._1),
+    fwd_expect: "{ ⸨a⸩: 5, b: 6, c: ⸨7⸩ }"
+  },
+  {file: "dict/foldl_with_index.fld", bwd_expect_file: "dict/foldl_with_index.expect.fld", "δv": select, fwd_expect: "⸨0⸩"},
+  {
+    file: "dict/intersectionWith.fld",
+    bwd_expect_file: "dict/intersectionWith.expect.fld",
+    "δv": x => App$dUtil$dSelector.dictVal("c")(select)(App$dUtil$dSelector.dictVal("b")(select)(x)._1),
+    fwd_expect: "{ b: ⸨0⸩, c: ⸨20⸩ }"
+  },
+  {file: "dict/get.fld", bwd_expect_file: "dict/get.expect.fld", "δv": select, fwd_expect: "⸨0⸩"},
+  {file: "dict/map.fld", bwd_expect_file: "dict/map.expect.fld", "δv": select, fwd_expect: "⸨20⸩"},
+  {file: "divide.fld", bwd_expect_file: "divide.expect.fld", "δv": select, fwd_expect: "⸨40.22222222222222⸩"},
+  {file: "dict/match.fld", bwd_expect_file: "dict/match.expect.fld", "δv": select, fwd_expect: ""},
+  {
+    file: "dtw/compute-dtw.fld",
+    bwd_expect_file: "dtw/compute-dtw.expect.fld",
+    fwd_expect: "(0, 0) :| ⸨(⸨1⸩, ⸨1⸩)⸩ :| (1, 2) :| (2, 3) :| (3, 4) :| (4, 5) :| (4, 6) :| []",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listElement(1)(select)
+  },
+  {
+    file: "dtw/average-series.fld",
+    bwd_expect_file: "dtw/average-series.expect.fld",
+    fwd_expect: "2.5 :| 0.5 :| ⸨0.5⸩ :| 2.5 :| 2.5 :| 1.0 :| 0.5 :| []",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listElement(2)(select)
+  },
+  {file: "filter.fld", bwd_expect_file: "filter.expect.fld", "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(0)(select$p), fwd_expect: "⸨⸨8⸩ :| 7 :| []⸩"},
+  {
+    file: "intersperse.fld",
+    bwd_expect_file: "intersperse-1.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(1)(select$p),
+    fwd_expect: "1 :| ⸨0 :| 2 :| 0 :| 3 :| []⸩"
+  },
+  {
+    file: "intersperse.fld",
+    bwd_expect_file: "intersperse-2.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(2)(select$p),
+    fwd_expect: "⸨1 :| 0 :| ⸨2 :| 0 :| 3 :| []⸩⸩"
+  },
+  {file: "length.fld", bwd_expect_file: "length.expect.fld", "δv": select, fwd_expect: "⸨5⸩"},
+  {
+    file: "list-comp.fld",
+    bwd_expect_file: "list-comp-1.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(1)(select$p),
+    fwd_expect: "6.2 :| ⸨260 :| 19.9 :| 91 :| []⸩"
+  },
+  {
+    file: "list-comp.fld",
+    bwd_expect_file: "list-comp-2.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(2)(select$p),
+    fwd_expect: "6.2 :| 260 :| ⸨19.9 :| 91 :| []⸩"
+  },
+  {
+    file: "lookup.fld",
+    bwd_expect_file: "lookup.expect.fld",
+    "δv": v => {
+      if (v._3.tag === "Constr" && v._3._1 === "Some") {
+        return Data$dTuple.$Tuple(
+          Val.$Val(
+            (() => {
+              if (v._1.tag === "Inert") { return App$dUtil.Inert; }
+              if (v._1.tag === "Reactive") { return App$dUtil.$SelState("Reactive", {persistent: !v._1._1.persistent, transient: v._1._1.transient}); }
+              $runtime.fail();
+            })(),
+            v._2,
+            Val.$BaseVal("Constr", v._3._1, v._3._2)
+          ),
+          App$dUtil.Persistent
+        );
+      }
+      $runtime.fail();
+    },
+    fwd_expect: "⸨Some(\"Germany\")⸩"
+  },
+  {
+    file: "map.fld",
+    bwd_expect_file: "map.expect.fld",
+    "δv": x => App$dUtil$dSelector.listCell(1)(select$p)(App$dUtil$dSelector.listCell(0)(select$p)(x)._1),
+    fwd_expect: "⸨5 :| ⸨6 :| []⸩⸩"
+  },
+  {
+    file: "matrix-update.fld",
+    bwd_expect_file: "matrix-update.expect.fld",
+    fwd_expect: "15, 13, 6, 9, 16,\n12, ⸨4000⸩, 15, 4, 13,\n14, 9, 20, 8, 1,\n4, 10, 3, 7, 19,\n3, 11, 15, 2, 9",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.matrixElement(1)(1)(select)
+  },
+  {file: "multiply.fld", bwd_expect_file: "multiply.expect.fld", "δv": select, fwd_expect: "⸨0⸩"},
+  {file: "nth.fld", bwd_expect_file: "nth.expect.fld", "δv": select, fwd_expect: "⸨4⸩"},
+  {
+    file: "output-not-source.fld",
+    bwd_expect_file: "output-not-source.expect.fld",
+    fwd_expect: "(⸨3⸩, ⸨True⸩)",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.constrArg("Pair")(1)(select)
+  },
+  {
+    file: "section-5-example.fld",
+    bwd_expect_file: "section-5-example-1.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(0)(select$p),
+    fwd_expect: "⸨88 :| 6 :| 4 :| []⸩"
+  },
+  {
+    file: "section-5-example.fld",
+    bwd_expect_file: "section-5-example-2.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listElement(1)(select),
+    fwd_expect: "⸨88⸩ :| ⸨6⸩ :| ⸨4⸩ :| []"
+  },
+  {
+    file: "section-5-example.fld",
+    bwd_expect_file: "section-5-example-3.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(2)(select$p),
+    fwd_expect: "88 :| 6 :| ⸨4 :| []⸩"
+  },
+  {
+    file: "zeros.fld",
+    bwd_expect_file: "zeros-1.expect.fld",
+    "δv": x => App$dUtil$dSelector.listCell(2)(select$p)(App$dUtil$dSelector.listCell(0)(select$p)(x)._1),
+    fwd_expect: "⸨0 :| 0 :| ⸨[]⸩⸩"
+  },
+  {file: "zeros.fld", bwd_expect_file: "zeros-2.expect.fld", "δv": /* #__PURE__ */ App$dUtil$dSelector.listCell(2)(select$p), fwd_expect: "0 :| 0 :| ⸨[]⸩"},
+  {
+    file: "zipWith.fld",
+    bwd_expect_file: "zipWith-1.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.listElement(1)(x => Data$dTuple.$Tuple(
+      Val.functorVal.map(x$1 => {
+        if (x$1.tag === "Inert") { return App$dUtil.Inert; }
+        if (x$1.tag === "Reactive") { return App$dUtil.$SelState("Reactive", {persistent: !x$1._1.persistent, transient: !x$1._1.transient}); }
+        $runtime.fail();
+      })(x),
+      App$dUtil.Persistent
+    )),
+    fwd_expect: "13.0 :| ⸨25.0⸩ :| 41.0 :| []"
+  },
+  {
+    file: "linkedOutputs/bar-chart-line-chart.fld",
+    bwd_expect_file: "linkedOutputs/bar-chart-line-chart.expect.fld",
+    "δv": /* #__PURE__ */ App$dUtil$dSelector.multiViewEntry(0)(/* #__PURE__ */ App$dUtil$dSelector.constrArg("BarChart")(0)(/* #__PURE__ */ App$dUtil$dSelector.barSegment(1)(0)(select))),
+    fwd_expect: "MultiView(BarChart({\n  caption: \"Total output by country\",\n  legend: True,\n  size: { height: 185, width: 275 },\n  stackedBars: { segments: { y: \"output\", z: 295.3 } :| [], x: \"China\" } :| {\n    segments: { y: \"output\", z: ⸨196.7⸩ } :| [],\n    x: \"USA\"\n  } :| { segments: { y: \"output\", z: 97.69999999999999 } :| [], x: \"Germany\" } :| [],\n  tickLabels: { x: Default, y: Default }\n}) :| LineChart({\n  caption: \"Output of USA relative to China\",\n  plots: LinePlot({\n    name: \"Bio\",\n    points: { x: 2013, y: 2.5483870967741935 } :| { x: 2014, y: 1.61 } :| {\n      x: 2015,\n      y: 1.6213592233009706\n    } :| { x: 2016, y: 1.4000000000000001 } :| {\n      x: 2017,\n      y: 1.1208053691275166\n    } :| { x: 2018, y: 0.9101123595505617 } :| []\n  }) :| LinePlot({\n    name: \"Hydro\",\n    points: { x: 2013, y: 0.3 } :| { x: 2014, y: 0.28214285714285714 } :| {\n      x: 2015,\n      y: 0.8333333333333334\n    } :| { x: 2016, y: 0.26229508196721313 } :| {\n      x: 2017,\n      y: 0.25559105431309903\n    } :| { x: 2018, y: 0.2484472049689441 } :| []\n  }) :| LinePlot({\n    name: \"Solar\",\n    points: { x: 2013, y: 0.6080402010050252 } :| {\n      x: 2014,\n      y: 0.6428571428571429\n    } :| { x: 2015, y: 0.5909090909090909 } :| {\n      x: 2016,\n      y: 0.5324675324675324\n    } :| { x: 2017, y: 0.3893129770992366 } :| {\n      x: 2018,\n      y: 0.3522727272727273\n    } :| []\n  }) :| LinePlot({\n    name: \"Wind\",\n    points: { x: 2013, y: 0.6703296703296703 } :| {\n      x: 2014,\n      y: 0.5739130434782609\n    } :| { x: 2015, y: 0.5103448275862069 } :| {\n      x: 2016,\n      y: 0.48520710059171596\n    } :| { x: 2017, y: 0.4734042553191489 } :| {\n      x: 2018,\n      y: 0.45714285714285713\n    } :| []\n  }) :| [],\n  size: { height: 285, width: 330 },\n  tickLabels: { x: Default, y: Default }\n}) :| [])"
+  },
+  {
+    file: "linkedOutputs/stacked-bar-scatter-plot.fld",
+    bwd_expect_file: "linkedOutputs/stacked-bar-scatter-plot.expect.fld",
+    "δv": /* #__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))),
+    fwd_expect: "MultiView(BarChart({\n  caption: \"Non-renewables by country\",\n  legend: True,\n  size: { height: 185, width: 275 },\n  stackedBars: {\n    segments: { y: \"BRA\", z: 151.05 } :| { y: \"EGY\", z: 159.93 } :| {\n      y: \"IND\",\n      z: 1060.1799999999998\n    } :| { y: \"JPN\", z: 928.82 } :| [],\n    x: \"2014\"\n  } :| {\n    segments: { y: \"BRA\", z: 142.76 } :| { y: \"EGY\", z: 170.68 } :| {\n      y: \"IND\",\n      z: 1118.8899999999999\n    } :| { y: \"JPN\", z: 876.0999999999999 } :| [],\n    x: \"2015\"\n  } :| {\n    segments: { y: \"BRA\", z: 108.03 } :| { y: \"EGY\", z: 174.07999999999998 } :| {\n      y: \"IND\",\n      z: 1193.53\n    } :| { y: \"JPN\", z: 883.3299999999999 } :| [],\n    x: \"2016\"\n  } :| {\n    segments: { y: \"BRA\", z: 116.76 } :| { y: \"EGY\", z: 181.31 } :| {\n      y: \"IND\",\n      z: ⸨1236.43⸩\n    } :| { y: \"JPN\", z: 875.32 } :| [],\n    x: \"2017\"\n  } :| {\n    segments: { y: \"BRA\", z: 101.48 } :| { y: \"EGY\", z: ⸨182.31⸩ } :| {\n      y: \"IND\",\n      z: 1315.57\n    } :| { y: \"JPN\", z: ⸨873.39⸩ } :| [],\n    x: \"2018\"\n  } :| [],\n  tickLabels: { x: Default, y: Default }\n}) :| ScatterPlot({\n  caption: \"Clean energy efficiency vs proportion of renewable energy capacity\",\n  labels: { x: \"Renewables/TotalEnergyCap\", y: \"Clean Capacity Factor\" },\n  points: { x: 0.8723185510332055, y: 0.4180741155728385 } :| {\n    x: 0.383891020964826,\n    y: 0.3306374135311273\n  } :| { x: 0.5685559399722339, y: 0.2651713517303818 } :| {\n    x: 0.39179907463864283,\n    y: 0.5311676111397315\n  } :| { x: 0.0886691179578209, y: 0.4125357483317445 } :| {\n    x: 0.3167847396421975,\n    y: 0.2767379556904734\n  } :| { x: 0.3129857171819161, y: 0.20426921772653447 } :| {\n    x: 0.29687029792356306,\n    y: 0.3462200657379872\n  } :| { x: 0.16239390265026848, y: 0.4128 } :| {\n    x: 0.2115752867627615,\n    y: 0.5086651868096602\n  } :| []\n}) :| [])"
+  },
+  {
+    file: "qcut.fld",
+    bwd_expect_file: "qcut.expect.fld",
+    "δv": v => Data$dTuple.$Tuple(v, App$dUtil.Persistent),
+    fwd_expect: "(1.01 :| 1.05 :| [], 0.051000000000000156) :| (1.07 :| 1.09 :| 1.22 :| 1.23 :| 1.24 :| 1.24 :| 1.25 :| 1.32 :| 1.32 :| 1.35 :| 1.39 :| 1.47 :| 1.57 :| 1.72 :| [], 0.6639999999999999) :| (1.73 :| 1.75 :| 1.76 :| 1.83 :| 1.87 :| 1.94 :| 2.04 :| 2.14 :| 2.18 :| 2.36 :| 2.37 :| 2.38 :| 2.52 :| 2.54 :| [], 0.8464999999999998) :| (2.61 :| 2.67 :| [], 0.09850000000000003) :| []"
+  }
+];
+export {bwd_cases, select, select$p};

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

@@ -0,0 +1,25 @@
+const comments_cases = [
+  {
+    file: "comments/nested-constr.fld",
+    fwd_expect: "@doc(Paragraph(\"This\" :| \"is\" :| \"a\" :| (@doc(Paragraph(\"This\" :| \"is\" :| \"a\" :| \"nested\" :| \"docComment!\" :| [])) \"some string\") :| \"docComment!\" :| [])) False"
+  },
+  {
+    file: "comments/dicts.fld",
+    fwd_expect: "@doc(Paragraph(\"We\" :| \"can\" :| \"have\" :| \"a\" :| \"docComment\" :| \"before\" :| \"a\" :| \"dict!\" :| [])) {\n  d: {},\n  e: { a: 5, ab: 6 },\n  e_ab: 6,\n  f: { a: 6, ab: 7 },\n  g: { a: 5 }\n}"
+  },
+  {
+    file: "comments/app-arg.fld",
+    fwd_expect: "@doc(Paragraph(\"Comments\" :| \"on\" :| \"arguments\" :| \"don't\" :| \"surface\" :| \"on\" :| \"the\" :| \"outermost\" :| \"application\" :| [])) 5 :| 7 :| 13 :| 15 :| 4 :| 3 :| -3 :| []"
+  },
+  {
+    file: "comments/list-comp.fld",
+    fwd_expect: "@doc(Paragraph(\"We\" :| \"can\" :| \"add\" :| \"comments\" :| \"to\" :| \"list\" :| \"comprehensions\" :| [])) 14 :| 12 :| 10 :| 13 :| 11 :| 9 :| 12 :| 10 :| 8 :| []"
+  },
+  {
+    file: "comments/app.fld",
+    fwd_expect: "@doc(Paragraph(\"This\" :| \"function\" :| \"application\" :| \"returns\" :| \"the\" :| \"length\" :| \"of\" :| \"a\" :| \"list.\" :| [])) 2"
+  },
+  {file: "comments/int.fld", fwd_expect: "@doc(Paragraph(\"Comment\" :| \"on\" :| \"1\" :| [])) 1"},
+  {file: "comments/projection.fld", fwd_expect: "1"}
+];
+export {comments_cases};

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

@@ -0,0 +1,17 @@
+const desugar_cases = [
+  {file: "desugar/list-comp-1.fld", fwd_expect: "14 :| 12 :| 10 :| 13 :| 11 :| 9 :| 12 :| 10 :| 8 :| []"},
+  {
+    file: "desugar/list-comp-2.fld",
+    fwd_expect: "14 :| 14 :| 14 :| 12 :| 12 :| 12 :| 10 :| 10 :| 10 :| 13 :| 13 :| 13 :| 11 :| 11 :| 11 :| 9 :| 9 :| 9 :| 12 :| 12 :| 12 :| 10 :| 10 :| 10 :| 8 :| 8 :| 8 :| []"
+  },
+  {file: "desugar/list-comp-3.fld", fwd_expect: "9 :| 8 :| []"},
+  {file: "desugar/list-comp-4.fld", fwd_expect: "5 :| 4 :| 3 :| []"},
+  {file: "desugar/list-comp-5.fld", fwd_expect: "5 :| 4 :| 3 :| []"},
+  {file: "desugar/list-comp-6.fld", fwd_expect: "5 :| []"},
+  {file: "desugar/list-comp-7.fld", fwd_expect: "[] :| []"},
+  {file: "desugar/list-comp-8.fld", fwd_expect: "5 :| 4 :| 3 :| []"},
+  {file: "desugar/list-comp-9.fld", fwd_expect: "10 :| 19 :| []"},
+  {file: "desugar/list-comp-10.fld", fwd_expect: "[]"},
+  {file: "desugar/list-enum.fld", fwd_expect: "3 :| 4 :| 5 :| 6 :| 7 :| []"}
+];
+export {desugar_cases};

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

@@ -0,0 +1,7 @@
+const graphics_cases = [
+  {file: "graphics/background.fld", fwd_expect: ""},
+  {file: "graphics/grouped-bar-chart.fld", fwd_expect: ""},
+  {file: "graphics/line-chart.fld", fwd_expect: ""},
+  {file: "graphics/stacked-bar-chart.fld", fwd_expect: ""}
+];
+export {graphics_cases};

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

@@ -0,0 +1,52 @@
+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 linkedInputs_spec5 = {
+  spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["nonRenewables", "renewables"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+  "δ_in": /* #__PURE__ */ Data$dTuple.$Tuple("nonRenewables", /* #__PURE__ */ App$dUtil$dSelector.listElement(0)(/* #__PURE__ */ App$dUtil$dSelector.dictVal("coalCap")(select))),
+  in_expect: /* #__PURE__ */ (() => {
+    const $0 = App$dUtil$dSelector.envVal("nonRenewables")(App$dUtil$dSelector.listElement(0)(x => App$dUtil$dSelector.dictVal("petrolCap")(select)(App$dUtil$dSelector.dictVal("nuclearCap")(select)(App$dUtil$dSelector.dictVal("gasCap")(select)(App$dUtil$dSelector.dictVal("coalCap")(select)(x)._1)._1)._1)));
+    const $1 = App$dUtil$dSelector.envVal("renewables")(x => App$dUtil$dSelector.listElement(3)(App$dUtil$dSelector.dictVal("capacity")(select))(App$dUtil$dSelector.listElement(2)(App$dUtil$dSelector.dictVal("capacity")(select))(App$dUtil$dSelector.listElement(1)(App$dUtil$dSelector.dictVal("capacity")(select))(App$dUtil$dSelector.listElement(0)(App$dUtil$dSelector.dictVal("capacity")(select))(x)._1)._1)._1));
+    return x => $1($0(x)._1);
+  })(),
+  file: "linkedInputs/mini-energyscatter.fld"
+};
+const linkedInputs_spec4 = {
+  spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["renewables", "nonRenewables"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+  "δ_in": /* #__PURE__ */ Data$dTuple.$Tuple("renewables", /* #__PURE__ */ App$dUtil$dSelector.listElement(204)(/* #__PURE__ */ App$dUtil$dSelector.dictVal("capacity")(select))),
+  in_expect: /* #__PURE__ */ (() => {
+    const $0 = App$dUtil$dSelector.envVal("nonRenewables")(App$dUtil$dSelector.listElement(51)(x => App$dUtil$dSelector.dictVal("nuclearOut")(select)(App$dUtil$dSelector.dictVal("petrolCap")(select)(App$dUtil$dSelector.dictVal("nuclearCap")(select)(App$dUtil$dSelector.dictVal("gasCap")(select)(App$dUtil$dSelector.dictVal("coalCap")(select)(x)._1)._1)._1)._1)));
+    const $1 = App$dUtil$dSelector.envVal("renewables")((() => {
+      const $1 = App$dUtil$dSelector.listElement(204)(x => App$dUtil$dSelector.dictVal("output")(select)(App$dUtil$dSelector.dictVal("capacity")(select)(x)._1));
+      const $2 = App$dUtil$dSelector.listElement(205)(x => App$dUtil$dSelector.dictVal("output")(select)(App$dUtil$dSelector.dictVal("capacity")(select)(x)._1));
+      const $3 = App$dUtil$dSelector.listElement(206)(x => App$dUtil$dSelector.dictVal("output")(select)(App$dUtil$dSelector.dictVal("capacity")(select)(x)._1));
+      const $4 = App$dUtil$dSelector.listElement(207)(x => App$dUtil$dSelector.dictVal("output")(select)(App$dUtil$dSelector.dictVal("capacity")(select)(x)._1));
+      return x => $4($3($2($1(x)._1)._1)._1);
+    })());
+    return x => $1($0(x)._1);
+  })(),
+  file: "linkedInputs/energyscatter.fld"
+};
+const linkedInputs_spec3 = {
+  spec: {fluidSrcPaths: ["fluid", "test/fluid"], inputs: ["renewables", "nonRenewables"], query: Data$dMaybe.Nothing, linking: true, rowFilter: Data$dMaybe.Nothing},
+  "δ_in": /* #__PURE__ */ Data$dTuple.$Tuple("nonRenewables", /* #__PURE__ */ App$dUtil$dSelector.listElement(51)(/* #__PURE__ */ App$dUtil$dSelector.dictVal("coalCap")(select))),
+  in_expect: /* #__PURE__ */ (() => {
+    const $0 = App$dUtil$dSelector.envVal("nonRenewables")(App$dUtil$dSelector.listElement(51)(x => App$dUtil$dSelector.dictVal("petrolCap")(select)(App$dUtil$dSelector.dictVal("nuclearCap")(select)(App$dUtil$dSelector.dictVal("gasCap")(select)(App$dUtil$dSelector.dictVal("coalCap")(select)(x)._1)._1)._1)));
+    const $1 = App$dUtil$dSelector.envVal("renewables")(x => App$dUtil$dSelector.listElement(207)(App$dUtil$dSelector.dictVal("capacity")(select))(App$dUtil$dSelector.listElement(206)(App$dUtil$dSelector.dictVal("capacity")(select))(App$dUtil$dSelector.listElement(205)(App$dUtil$dSelector.dictVal("capacity")(select))(App$dUtil$dSelector.listElement(204)(App$dUtil$dSelector.dictVal("capacity")(select))(x)._1)._1)._1));
+    return x => $1($0(x)._1);
+  })(),
+  file: "linkedInputs/energyscatter.fld"
+};
+const linkedInputs_cases = [linkedInputs_spec3, linkedInputs_spec4, linkedInputs_spec5];
+export {linkedInputs_cases, linkedInputs_spec3, linkedInputs_spec4, linkedInputs_spec5, select};