@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Safe.Coerce/index.js

@@ -0,0 +1,3 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const coerce = () => Unsafe$dCoerce.unsafeCoerce;
+export {coerce};

package/output-es/Test.Assert/foreign.js

@@ -0,0 +1,21 @@
+export function assertImpl(message) {
+  return function (success) {
+    return function () {
+      if (!success) throw new Error(message);
+    };
+  };
+}
+
+export function checkThrows(fn) {
+  return function () {
+    try {
+      fn();
+      return false;
+    } catch (e) {
+      if (e instanceof Error) return true;
+      var err = new Error("Threw something other than an Error");
+      err.something = e;
+      throw err;
+    }
+  };
+}

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

@@ -0,0 +1,37 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import {assertImpl, checkThrows} from "./foreign.js";
+const assert$p = assertImpl;
+const assertEqual$p = dictEq => dictShow => userMessage => v => {
+  const result = dictEq.eq(v.actual)(v.expected);
+  const message = (userMessage === "" ? "Expected: " : userMessage + "\nExpected: ") + dictShow.show(v.expected) + "\nActual:   " + dictShow.show(v.actual);
+  const $0 = Effect$dConsole.error(message);
+  const $1 = (() => {
+    if (!result) { return $0; }
+    if (result) { return () => {}; }
+    $runtime.fail();
+  })();
+  return () => {
+    $1();
+    return assertImpl(message)(result)();
+  };
+};
+const assertEqual = dictEq => dictShow => assertEqual$p(dictEq)(dictShow)("");
+const assertFalse = actual => assertEqual$p(Data$dEq.eqBoolean)(Data$dShow.showBoolean)("")({actual, expected: false});
+const assertTrue = actual => assertEqual$p(Data$dEq.eqBoolean)(Data$dShow.showBoolean)("")({actual, expected: true});
+const assertFalse$p = message => actual => assertEqual$p(Data$dEq.eqBoolean)(Data$dShow.showBoolean)(message)({actual, expected: false});
+const assertTrue$p = message => actual => assertEqual$p(Data$dEq.eqBoolean)(Data$dShow.showBoolean)(message)({actual, expected: true});
+const assertThrows$p = msg => fn => {
+  const $0 = assertImpl(msg);
+  const $1 = checkThrows(fn);
+  return () => {
+    const $2 = $1();
+    return $0($2)();
+  };
+};
+const assertThrows = /* #__PURE__ */ assertThrows$p("Assertion failed: An error should have been thrown");
+const assert = /* #__PURE__ */ assertImpl("Assertion failed");
+export {assert, assert$p, assertEqual, assertEqual$p, assertFalse, assertFalse$p, assertThrows, assertThrows$p, assertTrue, assertTrue$p};
+export * from "./foreign.js";

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

@@ -0,0 +1,3 @@
+export function microtime () {
+    return performance.now()
+}

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

@@ -0,0 +1,273 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dInt from "../Data.Int/index.js";
+import * as Data$dList from "../Data.List/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$dMonoid from "../Data.Monoid/index.js";
+import * as Data$dNumber from "../Data.Number/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dSet from "../Data.Set/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import {microtime} from "./foreign.js";
+const fold = /* #__PURE__ */ (() => Data$dFoldable.foldableArray.foldMap(Data$dMonoid.monoidString)(Data$dFoldable.identity))();
+const show = /* #__PURE__ */ (() => Data$dList$dTypes.showList(Data$dShow.showNumber).show)();
+const BenchRow = x => x;
+const BenchAcc = x => x;
+const showBenchAcc = {
+  show: v => fold(Data$dArray.intersperse("\n")([
+    fold(Data$dArray.intersperse(",")([
+      "Test-Name",
+      ...(() => {
+        const go = v$1 => {
+          if (v$1.tag === "Leaf") { return Data$dMap$dInternal.Leaf; }
+          if (v$1.tag === "Node") { return Data$dMap$dInternal.$$$Map("Node", v$1._1, v$1._2, v$1._3, undefined, go(v$1._5), go(v$1._6)); }
+          $runtime.fail();
+        };
+        return Data$dArray.fromFoldableImpl(
+          Data$dSet.foldableSet.foldr,
+          go((() => {
+            if (0 < v.length) { return v[0]._2; }
+            $runtime.fail();
+          })())
+        );
+      })()
+    ])),
+    ...Data$dFunctor.arrayMap(v2 => fold(Data$dArray.intersperse(",")([
+      v2._1,
+      ...Data$dFunctor.arrayMap(show)((() => {
+        const go = (m$p, z$p) => {
+          if (m$p.tag === "Leaf") { return z$p; }
+          if (m$p.tag === "Node") { return go(m$p._5, Data$dList$dTypes.$List("Cons", m$p._4, go(m$p._6, z$p))); }
+          $runtime.fail();
+        };
+        return Data$dArray.fromFoldableImpl(Data$dList$dTypes.foldableList.foldr, go(v2._2, Data$dList$dTypes.Nil));
+      })())
+    ])))(v)
+  ]))
+};
+const newtypeBenchRow_ = {Coercible0: () => {}};
+const semigroupBenchRow = {append: m1 => m2 => Data$dMap$dInternal.unsafeUnionWith(Data$dOrd.ordString.compare, Data$dList.union(Data$dEq.eqNumber), m1, m2)};
+const monoidBenchRow = {mempty: Data$dMap$dInternal.Leaf, Semigroup0: () => semigroupBenchRow};
+const stdDev = ns$p => Data$dNumber.sqrt((() => {
+  const $0 = Data$dList$dTypes.listMap(x => Data$dNumber.pow((() => {
+    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 = b + v._1;
+          go$a1 = v._2;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return x - go(0.0)(ns$p) / Data$dInt.toNumber((() => {
+      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 b = go$1$a0, v = go$1$a1;
+          if (v.tag === "Nil") {
+            go$1$c = false;
+            go$1$r = b;
+            continue;
+          }
+          if (v.tag === "Cons") {
+            go$1$a0 = b + 1 | 0;
+            go$1$a1 = v._2;
+            continue;
+          }
+          $runtime.fail();
+        }
+        return go$1$r;
+      };
+      return go$1(0)(ns$p);
+    })());
+  })())(2.0))(ns$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 = b + v._1;
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(0.0)($0) / Data$dInt.toNumber((() => {
+    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 b = go$1$a0, v = go$1$a1;
+        if (v.tag === "Nil") {
+          go$1$c = false;
+          go$1$r = b;
+          continue;
+        }
+        if (v.tag === "Cons") {
+          go$1$a0 = b + 1 | 0;
+          go$1$a1 = v._2;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$1$r;
+    };
+    return go$1(0)($0);
+  })());
+})());
+const stdErr = nums => stdDev(nums) / Data$dNumber.sqrt(Data$dInt.toNumber((() => {
+  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 = b + 1 | 0;
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(0)(nums);
+})()));
+const recordGraphSize = dictGraph => dictMonadWriter => g => dictMonadWriter.MonadTell1().tell(Data$dMap$dInternal.$$$Map(
+  "Node",
+  1,
+  1,
+  "Graph-Nodes",
+  Data$dList$dTypes.$List("Cons", Data$dInt.toNumber(dictGraph.size(g)), Data$dList$dTypes.Nil),
+  Data$dMap$dInternal.Leaf,
+  Data$dMap$dInternal.Leaf
+));
+const microtime$p = dictMonadEffect => dictMonadEffect.liftEffect(microtime);
+const time = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const $0 = Monad0.Bind1();
+  const microtime$p1 = dictMonadEffect.liftEffect(microtime);
+  return m => $0.bind(microtime$p1)(t1 => $0.bind(m())(x => $0.bind(microtime$p1)(t2 => Monad0.Applicative0().pure(Data$dTuple.$Tuple(t2 - t1, x)))));
+};
+const logAs = dictMonadEffect => tag => s => dictMonadEffect.liftEffect(Effect$dConsole.log(tag + ": " + s));
+const logTimeWhen = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const time1 = time(dictMonadEffect);
+  return v => v1 => v2 => {
+    if (!v) { return v2(); }
+    if (v) {
+      return Bind1.bind(time1(v2))(v3 => {
+        const $0 = v3._2;
+        return Bind1.bind(dictMonadEffect.liftEffect(Effect$dConsole.log(v1 + ": " + Data$dShow.showNumberImpl(v3._1))))(() => Monad0.Applicative0().pure($0));
+      });
+    }
+    $runtime.fail();
+  };
+};
+const divRow = v => n => {
+  const go = v$1 => {
+    if (v$1.tag === "Leaf") { return Data$dMap$dInternal.Leaf; }
+    if (v$1.tag === "Node") {
+      return Data$dMap$dInternal.$$$Map(
+        "Node",
+        v$1._1,
+        v$1._2,
+        v$1._3,
+        Data$dList$dTypes.$List(
+          "Cons",
+          (() => {
+            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 b = go$1$a0, v$2 = go$1$a1;
+                if (v$2.tag === "Nil") {
+                  go$1$c = false;
+                  go$1$r = b;
+                  continue;
+                }
+                if (v$2.tag === "Cons") {
+                  go$1$a0 = b + v$2._1;
+                  go$1$a1 = v$2._2;
+                  continue;
+                }
+                $runtime.fail();
+              }
+              return go$1$r;
+            };
+            return go$1(0.0)(v$1._4) / Data$dInt.toNumber(n);
+          })(),
+          Data$dList$dTypes.$List("Cons", stdErr(v$1._4), Data$dList$dTypes.Nil)
+        ),
+        go(v$1._5),
+        go(v$1._6)
+      );
+    }
+    $runtime.fail();
+  };
+  return go(v);
+};
+const benchmark$p = dictMonadWriter => name => m => dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const Applicative0 = Monad0.Applicative0();
+  const time1 = time(dictMonadEffect);
+  return dictMonadError => Bind1.bind(Applicative0.pure())(() => Bind1.bind(time1(m))(v => {
+    const $0 = v._2;
+    return Bind1.bind(dictMonadWriter.MonadTell1().tell(Data$dMap$dInternal.$$$Map(
+      "Node",
+      1,
+      1,
+      name,
+      Data$dList$dTypes.$List("Cons", v._1, Data$dList$dTypes.Nil),
+      Data$dMap$dInternal.Leaf,
+      Data$dMap$dInternal.Leaf
+    )))(() => Applicative0.pure($0));
+  }));
+};
+const benchmark = dictMonadWriter => name => benchmark$p(dictMonadWriter)(name);
+export {
+  BenchAcc,
+  BenchRow,
+  benchmark,
+  benchmark$p,
+  divRow,
+  fold,
+  logAs,
+  logTimeWhen,
+  microtime$p,
+  monoidBenchRow,
+  newtypeBenchRow_,
+  recordGraphSize,
+  semigroupBenchRow,
+  show,
+  showBenchAcc,
+  stdDev,
+  stdErr,
+  time
+};
+export * from "./foreign.js";

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

@@ -0,0 +1,297 @@
+// | This module is a partial port of the Haskell QuickCheck library.
+// |
+// | QuickCheck provides a way to write _property-based_ tests.
+// |
+// | The `Arbitrary` and `CoArbitrary` type classes allow us to create
+// | random data with which we can run our tests. This module provides
+// | instances of both classes for PureScript's core data structures,
+// | as well as functions for writing new instances.
+// |
+// | Test suites can use the `quickCheck` and `quickCheckPure` functions
+// | to test properties.
+// |
+// | For example:
+// |
+// | ```purescript
+// | main = quickCheck \n -> n + 1 > n
+// | ```
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Data$dFoldable from "../Data.Foldable/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$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect from "../Effect/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Random$dLCG from "../Random.LCG/index.js";
+import * as Test$dQuickCheck$dGen from "../Test.QuickCheck.Gen/index.js";
+const $Result = (tag, _1) => ({tag, _1});
+const for_ = /* #__PURE__ */ Data$dFoldable.for_(Effect.applicativeEffect)(Data$dFoldable.foldableFirst);
+const Success = /* #__PURE__ */ $Result("Success");
+const Failed = value0 => $Result("Failed", value0);
+const withHelp = v => v1 => {
+  if (v) { return Success; }
+  return $Result("Failed", v1);
+};
+const testableResult = /* #__PURE__ */ (() => ({test: Test$dQuickCheck$dGen.applicativeGen.pure}))();
+const testableBoolean = {
+  test: v => {
+    if (v) { return Test$dQuickCheck$dGen.applicativeGen.pure(Success); }
+    return Test$dQuickCheck$dGen.applicativeGen.pure($Result("Failed", "Test returned false"));
+  }
+};
+const test = dict => dict.test;
+const testableFunction = dictArbitrary => {
+  const arbitrary = dictArbitrary.arbitrary;
+  return dictTestable => ({test: f => Test$dQuickCheck$dGen.bindStateT.bind(arbitrary)(x => dictTestable.test(f(x)))});
+};
+const testableGen = dictTestable => (
+  {
+    test: (() => {
+      const $0 = dictTestable.test;
+      return a => Test$dQuickCheck$dGen.bindStateT.bind(a)($0);
+    })()
+  }
+);
+const showResult = {
+  show: v => {
+    if (v.tag === "Success") { return "Success"; }
+    if (v.tag === "Failed") { return "Failed: " + v._1; }
+    $runtime.fail();
+  }
+};
+const quickCheckWithSeed = dictTestable => initialSeed => n => prop => {
+  const $0 = v => {
+    if (v.index === n) { return Control$dMonad$dRec$dClass.$Step("Done", v); }
+    const v1 = dictTestable.test(prop)({newSeed: v.seed, size: 10});
+    if (v1._1.tag === "Success") {
+      return Control$dMonad$dRec$dClass.$Step("Loop", {seed: v1._2.newSeed, index: v.index + 1 | 0, successes: v.successes + 1 | 0, firstFailure: v.firstFailure});
+    }
+    if (v1._1.tag === "Failed") {
+      return Control$dMonad$dRec$dClass.$Step(
+        "Loop",
+        {
+          seed: v1._2.newSeed,
+          index: v.index + 1 | 0,
+          successes: v.successes,
+          firstFailure: v.firstFailure.tag === "Just" ? v.firstFailure : Data$dMaybe.$Maybe("Just", {index: v.index, message: v1._1._1, seed: v.seed})
+        }
+      );
+    }
+    $runtime.fail();
+  };
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0;
+      if (v.tag === "Loop") {
+        go$a0 = $0(v._1);
+        continue;
+      }
+      if (v.tag === "Done") {
+        go$c = false;
+        go$r = v._1;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const result = go($0({seed: initialSeed, index: 0, successes: 0, firstFailure: Data$dMaybe.Nothing}));
+  const $1 = Effect$dConsole.log(Data$dShow.showIntImpl(result.successes) + "/" + Data$dShow.showIntImpl(n) + " test(s) passed.");
+  return () => {
+    $1();
+    return for_(result.firstFailure)(v => Effect$dException.throwException(Effect$dException.error("Test " + Data$dShow.showIntImpl(v.index + 1 | 0) + " (seed " + Data$dShow.showIntImpl(v.seed) + ") failed: \n" + v.message)))();
+  };
+};
+const quickCheckPure$p = dictTestable => s => n => prop => {
+  const $0 = v => {
+    if (v.index === n) {
+      return Control$dMonad$dRec$dClass.$Step(
+        "Done",
+        (() => {
+          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 v$1 = go$a0, v1 = go$a1;
+              if (v1.tag === "Nil") {
+                go$c = false;
+                go$r = v$1;
+                continue;
+              }
+              if (v1.tag === "Cons") {
+                go$a0 = Data$dList$dTypes.$List("Cons", v1._1, v$1);
+                go$a1 = v1._2;
+                continue;
+              }
+              $runtime.fail();
+            }
+            return go$r;
+          };
+          return go(Data$dList$dTypes.Nil)(v.results);
+        })()
+      );
+    }
+    const v1 = dictTestable.test(prop)({newSeed: v.seed, size: 10});
+    return Control$dMonad$dRec$dClass.$Step(
+      "Loop",
+      {seed: v1._2.newSeed, index: v.index + 1 | 0, results: Data$dList$dTypes.$List("Cons", Data$dTuple.$Tuple(v.seed, v1._1), v.results)}
+    );
+  };
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0;
+      if (v.tag === "Loop") {
+        go$a0 = $0(v._1);
+        continue;
+      }
+      if (v.tag === "Done") {
+        go$c = false;
+        go$r = v._1;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go($0({seed: s, index: 0, results: Data$dList$dTypes.Nil}));
+};
+const quickCheckPure = dictTestable => s => n => prop => Data$dList$dTypes.listMap(Data$dTuple.snd)(quickCheckPure$p(dictTestable)(s)(n)(prop));
+const quickCheckGenWithSeed = dictTestable => quickCheckWithSeed({
+  test: (() => {
+    const $0 = dictTestable.test;
+    return a => Test$dQuickCheck$dGen.bindStateT.bind(a)($0);
+  })()
+});
+const quickCheckGenPure$p = dictTestable => quickCheckPure$p({
+  test: (() => {
+    const $0 = dictTestable.test;
+    return a => Test$dQuickCheck$dGen.bindStateT.bind(a)($0);
+  })()
+});
+const quickCheckGenPure = dictTestable => quickCheckPure({
+  test: (() => {
+    const $0 = dictTestable.test;
+    return a => Test$dQuickCheck$dGen.bindStateT.bind(a)($0);
+  })()
+});
+const quickCheck$p = dictTestable => n => prop => () => {
+  const seed = Random$dLCG.randomSeed();
+  return quickCheckWithSeed(dictTestable)(seed)(n)(prop)();
+};
+const quickCheckGen$p = dictTestable => quickCheck$p({
+  test: (() => {
+    const $0 = dictTestable.test;
+    return a => Test$dQuickCheck$dGen.bindStateT.bind(a)($0);
+  })()
+});
+const quickCheck = dictTestable => prop => () => {
+  const seed = Random$dLCG.randomSeed();
+  return quickCheckWithSeed(dictTestable)(seed)(100)(prop)();
+};
+const quickCheckGen = dictTestable => quickCheck({
+  test: (() => {
+    const $0 = dictTestable.test;
+    return a => Test$dQuickCheck$dGen.bindStateT.bind(a)($0);
+  })()
+});
+const printSummary = summary => Data$dShow.showIntImpl(summary.successes) + "/" + Data$dShow.showIntImpl(summary.total) + (summary.total === 1 ? " test passed." : " tests passed.");
+const checkResults = /* #__PURE__ */ (() => {
+  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 = Data$dTuple.$Tuple(
+          b._1 + 1 | 0,
+          (() => {
+            if (v._1._2.tag === "Success") { return {total: b._2.total + 1 | 0, successes: b._2.successes + 1 | 0, failures: b._2.failures}; }
+            if (v._1._2.tag === "Failed") {
+              return {
+                total: b._2.total + 1 | 0,
+                successes: b._2.successes,
+                failures: Data$dList$dTypes.$List("Cons", {index: b._1, seed: v._1._1, message: v._1._2._1}, b._2.failures)
+              };
+            }
+            $runtime.fail();
+          })()
+        );
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const $0 = go(Data$dTuple.$Tuple(0, {total: 0, successes: 0, failures: Data$dList$dTypes.Nil}));
+  return x => $0(x)._2;
+})();
+const assertNotEquals = dictEq => dictShow => a => b => {
+  const $0 = dictShow.show(a) + " == " + dictShow.show(b);
+  if (!dictEq.eq(a)(b)) { return Success; }
+  return $Result("Failed", $0);
+};
+const assertLessThanEq = dictOrd => dictShow => a => b => {
+  const $0 = dictShow.show(a) + " > " + dictShow.show(b);
+  if (dictOrd.compare(a)(b) !== "GT") { return Success; }
+  return $Result("Failed", $0);
+};
+const assertLessThan = dictOrd => dictShow => a => b => {
+  const $0 = dictShow.show(a) + " >= " + dictShow.show(b);
+  if (dictOrd.compare(a)(b) === "LT") { return Success; }
+  return $Result("Failed", $0);
+};
+const assertGreaterThanEq = dictOrd => dictShow => a => b => {
+  const $0 = dictShow.show(a) + " < " + dictShow.show(b);
+  if (dictOrd.compare(a)(b) !== "LT") { return Success; }
+  return $Result("Failed", $0);
+};
+const assertGreaterThan = dictOrd => dictShow => a => b => {
+  const $0 = dictShow.show(a) + " <= " + dictShow.show(b);
+  if (dictOrd.compare(a)(b) === "GT") { return Success; }
+  return $Result("Failed", $0);
+};
+const assertEquals = dictEq => dictShow => a => b => {
+  const $0 = dictShow.show(a) + " /= " + dictShow.show(b);
+  if (dictEq.eq(a)(b)) { return Success; }
+  return $Result("Failed", $0);
+};
+export {
+  $Result,
+  Failed,
+  Success,
+  assertEquals,
+  assertGreaterThan,
+  assertGreaterThanEq,
+  assertLessThan,
+  assertLessThanEq,
+  assertNotEquals,
+  checkResults,
+  for_,
+  printSummary,
+  quickCheck,
+  quickCheck$p,
+  quickCheckGen,
+  quickCheckGen$p,
+  quickCheckGenPure,
+  quickCheckGenPure$p,
+  quickCheckGenWithSeed,
+  quickCheckPure,
+  quickCheckPure$p,
+  quickCheckWithSeed,
+  showResult,
+  test,
+  testableBoolean,
+  testableFunction,
+  testableGen,
+  testableResult,
+  withHelp
+};