@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Data.Array.ST.Iterator/index.js

@@ -0,0 +1,83 @@
+import * as $runtime from "../runtime.js";
+const $Iterator = (_1, _2) => ({tag: "Iterator", _1, _2});
+const Iterator = value0 => value1 => $Iterator(value0, value1);
+const peek = v => {
+  const $0 = v._2;
+  return () => {
+    const i = $0.value;
+    return v._1(i);
+  };
+};
+const next = v => {
+  const $0 = v._2;
+  return () => {
+    const i = $0.value;
+    const $1 = $0.value;
+    $0.value = $1 + 1 | 0;
+    return v._1(i);
+  };
+};
+const pushWhile = p => iter => array => () => {
+  let $$break = false;
+  const $0 = iter._2;
+  while (
+    (() => {
+      const $1 = $$break;
+      return !$1;
+    })()
+  ) {
+    const i = $0.value;
+    const mx = iter._1(i);
+    if (mx.tag === "Just" && p(mx._1)) {
+      array.push(mx._1);
+      iter._2.value;
+      const $1 = iter._2.value;
+      iter._2.value = $1 + 1 | 0;
+      continue;
+    }
+    $$break = true;
+  }
+};
+const pushAll = /* #__PURE__ */ pushWhile(v => true);
+const iterator = f => {
+  const $0 = Iterator(f);
+  return () => {
+    const $1 = {value: 0};
+    return $0($1);
+  };
+};
+const iterate = iter => f => () => {
+  let $$break = false;
+  const $0 = iter._2;
+  while (
+    (() => {
+      const $1 = $$break;
+      return !$1;
+    })()
+  ) {
+    const i = $0.value;
+    const $1 = $0.value;
+    $0.value = $1 + 1 | 0;
+    const mx = iter._1(i);
+    if (mx.tag === "Just") {
+      f(mx._1)();
+      continue;
+    }
+    if (mx.tag === "Nothing") {
+      $$break = true;
+      continue;
+    }
+    $runtime.fail();
+  }
+};
+const exhausted = x => {
+  const $0 = x._2;
+  return () => {
+    const i = $0.value;
+    const $1 = x._1(i);
+    if ($1.tag === "Nothing") { return true; }
+    if ($1.tag === "Just") { return false; }
+    $runtime.fail();
+  };
+};
+export {$Iterator, Iterator, exhausted, iterate, iterator, next, peek, pushAll, pushWhile};

package/output-es/Data.Array.ST.Partial/foreign.js

@@ -0,0 +1,7 @@
+export const peekImpl = function (i, xs) {
+  return xs[i];
+};
+
+export const pokeImpl = function (i, a, xs) {
+  xs[i] = a;
+};

package/output-es/Data.Array.ST.Partial/index.js

@@ -0,0 +1,9 @@
+// | Partial functions for working with mutable arrays using the `ST` effect.
+// |
+// | This module is particularly helpful when performance is very important.
+import * as Control$dMonad$dST$dUncurried from "../Control.Monad.ST.Uncurried/index.js";
+import {peekImpl, pokeImpl} from "./foreign.js";
+const poke = () => Control$dMonad$dST$dUncurried.runSTFn3(pokeImpl);
+const peek = () => Control$dMonad$dST$dUncurried.runSTFn2(peekImpl);
+export {peek, poke};
+export * from "./foreign.js";

package/output-es/Data.ArrayBuffer.Types/index.js

@@ -0,0 +1 @@
+export {};

package/output-es/Data.Bifoldable/index.js

@@ -0,0 +1,149 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dApply from "../Control.Apply/index.js";
+const identity = x => x;
+const monoidEndo = /* #__PURE__ */ (() => {
+  const semigroupEndo1 = {append: v => v1 => x => v(v1(x))};
+  return {mempty: x => x, Semigroup0: () => semigroupEndo1};
+})();
+const monoidDual = /* #__PURE__ */ (() => {
+  const $0 = monoidEndo.Semigroup0();
+  const semigroupDual1 = {append: v => v1 => $0.append(v1)(v)};
+  return {mempty: monoidEndo.mempty, Semigroup0: () => semigroupDual1};
+})();
+const bifoldr = dict => dict.bifoldr;
+const bitraverse_ = dictBifoldable => dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const applySecond = a => b => $0.apply($0.Functor0().map(v => Control$dApply.identity)(a))(b);
+  return f => g => dictBifoldable.bifoldr(x => applySecond(f(x)))(x => applySecond(g(x)))(dictApplicative.pure());
+};
+const bifor_ = dictBifoldable => dictApplicative => {
+  const bitraverse_2 = bitraverse_(dictBifoldable)(dictApplicative);
+  return t => f => g => bitraverse_2(f)(g)(t);
+};
+const bisequence_ = dictBifoldable => dictApplicative => bitraverse_(dictBifoldable)(dictApplicative)(identity)(identity);
+const bifoldl = dict => dict.bifoldl;
+const bifoldableTuple = {
+  bifoldMap: dictMonoid => f => g => v => dictMonoid.Semigroup0().append(f(v._1))(g(v._2)),
+  bifoldr: f => g => z => v => f(v._1)(g(v._2)(z)),
+  bifoldl: f => g => z => v => g(f(z)(v._1))(v._2)
+};
+const bifoldableJoker = dictFoldable => (
+  {
+    bifoldr: v => r => u => v1 => dictFoldable.foldr(r)(u)(v1),
+    bifoldl: v => r => u => v1 => dictFoldable.foldl(r)(u)(v1),
+    bifoldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return v => r => v1 => foldMap1(r)(v1);
+    }
+  }
+);
+const bifoldableEither = {
+  bifoldr: v => v1 => v2 => v3 => {
+    if (v3.tag === "Left") { return v(v3._1)(v2); }
+    if (v3.tag === "Right") { return v1(v3._1)(v2); }
+    $runtime.fail();
+  },
+  bifoldl: v => v1 => v2 => v3 => {
+    if (v3.tag === "Left") { return v(v2)(v3._1); }
+    if (v3.tag === "Right") { return v1(v2)(v3._1); }
+    $runtime.fail();
+  },
+  bifoldMap: dictMonoid => v => v1 => v2 => {
+    if (v2.tag === "Left") { return v(v2._1); }
+    if (v2.tag === "Right") { return v1(v2._1); }
+    $runtime.fail();
+  }
+};
+const bifoldableConst = {bifoldr: f => v => z => v1 => f(v1)(z), bifoldl: f => v => z => v1 => f(z)(v1), bifoldMap: dictMonoid => f => v => v1 => f(v1)};
+const bifoldableClown = dictFoldable => (
+  {
+    bifoldr: l => v => u => v1 => dictFoldable.foldr(l)(u)(v1),
+    bifoldl: l => v => u => v1 => dictFoldable.foldl(l)(u)(v1),
+    bifoldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return l => v => v1 => foldMap1(l)(v1);
+    }
+  }
+);
+const bifoldMapDefaultR = dictBifoldable => dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const mempty = dictMonoid.mempty;
+  return f => g => dictBifoldable.bifoldr(x => $0.append(f(x)))(x => $0.append(g(x)))(mempty);
+};
+const bifoldMapDefaultL = dictBifoldable => dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const mempty = dictMonoid.mempty;
+  return f => g => dictBifoldable.bifoldl(m => a => $0.append(m)(f(a)))(m => b => $0.append(m)(g(b)))(mempty);
+};
+const bifoldMap = dict => dict.bifoldMap;
+const bifoldableFlip = dictBifoldable => (
+  {
+    bifoldr: r => l => u => v => dictBifoldable.bifoldr(l)(r)(u)(v),
+    bifoldl: r => l => u => v => dictBifoldable.bifoldl(l)(r)(u)(v),
+    bifoldMap: dictMonoid => {
+      const bifoldMap2 = dictBifoldable.bifoldMap(dictMonoid);
+      return r => l => v => bifoldMap2(l)(r)(v);
+    }
+  }
+);
+const bifoldlDefault = dictBifoldable => {
+  const bifoldMap1 = dictBifoldable.bifoldMap(monoidDual);
+  return f => g => z => p => bifoldMap1(x => a => f(a)(x))(x => a => g(a)(x))(p)(z);
+};
+const bifoldrDefault = dictBifoldable => {
+  const bifoldMap1 = dictBifoldable.bifoldMap(monoidEndo);
+  return f => g => z => p => bifoldMap1(x => f(x))(x => g(x))(p)(z);
+};
+const bifoldableProduct2 = dictBifoldable => dictBifoldable1 => (
+  {
+    bifoldr: l => r => u => m => bifoldrDefault(bifoldableProduct2(dictBifoldable)(dictBifoldable1))(l)(r)(u)(m),
+    bifoldl: l => r => u => m => bifoldlDefault(bifoldableProduct2(dictBifoldable)(dictBifoldable1))(l)(r)(u)(m),
+    bifoldMap: dictMonoid => {
+      const bifoldMap3 = dictBifoldable.bifoldMap(dictMonoid);
+      const bifoldMap4 = dictBifoldable1.bifoldMap(dictMonoid);
+      return l => r => v => dictMonoid.Semigroup0().append(bifoldMap3(l)(r)(v._1))(bifoldMap4(l)(r)(v._2));
+    }
+  }
+);
+const bifold = dictBifoldable => dictMonoid => dictBifoldable.bifoldMap(dictMonoid)(identity)(identity);
+const biany = dictBifoldable => dictBooleanAlgebra => {
+  const bifoldMap2 = dictBifoldable.bifoldMap((() => {
+    const $0 = dictBooleanAlgebra.HeytingAlgebra0();
+    const semigroupDisj1 = {append: v => v1 => $0.disj(v)(v1)};
+    return {mempty: $0.ff, Semigroup0: () => semigroupDisj1};
+  })());
+  return p => q => bifoldMap2(x => p(x))(x => q(x));
+};
+const biall = dictBifoldable => dictBooleanAlgebra => {
+  const bifoldMap2 = dictBifoldable.bifoldMap((() => {
+    const $0 = dictBooleanAlgebra.HeytingAlgebra0();
+    const semigroupConj1 = {append: v => v1 => $0.conj(v)(v1)};
+    return {mempty: $0.tt, Semigroup0: () => semigroupConj1};
+  })());
+  return p => q => bifoldMap2(x => p(x))(x => q(x));
+};
+export {
+  biall,
+  biany,
+  bifold,
+  bifoldMap,
+  bifoldMapDefaultL,
+  bifoldMapDefaultR,
+  bifoldableClown,
+  bifoldableConst,
+  bifoldableEither,
+  bifoldableFlip,
+  bifoldableJoker,
+  bifoldableProduct2,
+  bifoldableTuple,
+  bifoldl,
+  bifoldlDefault,
+  bifoldr,
+  bifoldrDefault,
+  bifor_,
+  bisequence_,
+  bitraverse_,
+  identity,
+  monoidDual,
+  monoidEndo
+};

package/output-es/Data.Bifunctor/index.js

@@ -0,0 +1,17 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const bimap = dict => dict.bimap;
+const lmap = dictBifunctor => f => dictBifunctor.bimap(f)(identity);
+const rmap = dictBifunctor => dictBifunctor.bimap(identity);
+const bifunctorTuple = {bimap: f => g => v => Data$dTuple.$Tuple(f(v._1), g(v._2))};
+const bifunctorEither = {
+  bimap: v => v1 => v2 => {
+    if (v2.tag === "Left") { return Data$dEither.$Either("Left", v(v2._1)); }
+    if (v2.tag === "Right") { return Data$dEither.$Either("Right", v1(v2._1)); }
+    $runtime.fail();
+  }
+};
+const bifunctorConst = {bimap: f => v => v1 => f(v1)};
+export {bifunctorConst, bifunctorEither, bifunctorTuple, bimap, identity, lmap, rmap};

package/output-es/Data.Bifunctor.Join/index.js

@@ -0,0 +1,21 @@
+const Join = x => x;
+const showJoin = dictShow => ({show: v => "(Join " + dictShow.show(v) + ")"});
+const ordJoin = dictOrd => dictOrd;
+const newtypeJoin = {Coercible0: () => {}};
+const eqJoin = dictEq => dictEq;
+const bifunctorJoin = dictBifunctor => ({map: f => v => dictBifunctor.bimap(f)(f)(v)});
+const biapplyJoin = dictBiapply => {
+  const $0 = dictBiapply.Bifunctor0();
+  const bifunctorJoin1 = {map: f => v => $0.bimap(f)(f)(v)};
+  return {apply: v => v1 => dictBiapply.biapply(v)(v1), Functor0: () => bifunctorJoin1};
+};
+const biapplicativeJoin = dictBiapplicative => {
+  const $0 = dictBiapplicative.Biapply0();
+  const $1 = $0.Bifunctor0();
+  const biapplyJoin1 = (() => {
+    const bifunctorJoin1 = {map: f => v => $1.bimap(f)(f)(v)};
+    return {apply: v => v1 => $0.biapply(v)(v1), Functor0: () => bifunctorJoin1};
+  })();
+  return {pure: a => dictBiapplicative.bipure(a)(a), Apply0: () => biapplyJoin1};
+};
+export {Join, biapplicativeJoin, biapplyJoin, bifunctorJoin, eqJoin, newtypeJoin, ordJoin, showJoin};

package/output-es/Data.Bitraversable/index.js

@@ -0,0 +1,195 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dBifoldable from "../Data.Bifoldable/index.js";
+import * as Data$dBifunctor from "../Data.Bifunctor/index.js";
+import * as Data$dConst from "../Data.Const/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor$dClown from "../Data.Functor.Clown/index.js";
+import * as Data$dFunctor$dFlip from "../Data.Functor.Flip/index.js";
+import * as Data$dFunctor$dJoker from "../Data.Functor.Joker/index.js";
+import * as Data$dFunctor$dProduct2 from "../Data.Functor.Product2/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const bitraverse = dict => dict.bitraverse;
+const lfor = dictBitraversable => dictApplicative => {
+  const bitraverse2 = dictBitraversable.bitraverse(dictApplicative);
+  const pure = dictApplicative.pure;
+  return t => f => bitraverse2(f)(pure)(t);
+};
+const ltraverse = dictBitraversable => dictApplicative => {
+  const bitraverse2 = dictBitraversable.bitraverse(dictApplicative);
+  const pure = dictApplicative.pure;
+  return f => bitraverse2(f)(pure);
+};
+const rfor = dictBitraversable => dictApplicative => {
+  const bitraverse2 = dictBitraversable.bitraverse(dictApplicative);
+  const pure = dictApplicative.pure;
+  return t => f => bitraverse2(pure)(f)(t);
+};
+const rtraverse = dictBitraversable => dictApplicative => dictBitraversable.bitraverse(dictApplicative)(dictApplicative.pure);
+const bitraversableTuple = {
+  bitraverse: dictApplicative => {
+    const Apply0 = dictApplicative.Apply0();
+    return f => g => v => Apply0.apply(Apply0.Functor0().map(Data$dTuple.Tuple)(f(v._1)))(g(v._2));
+  },
+  bisequence: dictApplicative => {
+    const Apply0 = dictApplicative.Apply0();
+    return v => Apply0.apply(Apply0.Functor0().map(Data$dTuple.Tuple)(v._1))(v._2);
+  },
+  Bifunctor0: () => Data$dBifunctor.bifunctorTuple,
+  Bifoldable1: () => Data$dBifoldable.bifoldableTuple
+};
+const bitraversableJoker = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const bifunctorJoker = {bimap: v => g => v1 => $0.map(g)(v1)};
+  const $1 = dictTraversable.Foldable1();
+  const bifoldableJoker = {
+    bifoldr: v => r => u => v1 => $1.foldr(r)(u)(v1),
+    bifoldl: v => r => u => v1 => $1.foldl(r)(u)(v1),
+    bifoldMap: dictMonoid => {
+      const foldMap1 = $1.foldMap(dictMonoid);
+      return v => r => v1 => foldMap1(r)(v1);
+    }
+  };
+  return {
+    bitraverse: dictApplicative => {
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return v => r => v1 => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dJoker.Joker)(traverse1(r)(v1));
+    },
+    bisequence: dictApplicative => {
+      const sequence1 = dictTraversable.sequence(dictApplicative);
+      return v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dJoker.Joker)(sequence1(v));
+    },
+    Bifunctor0: () => bifunctorJoker,
+    Bifoldable1: () => bifoldableJoker
+  };
+};
+const bitraversableEither = {
+  bitraverse: dictApplicative => {
+    const $0 = dictApplicative.Apply0().Functor0();
+    return v => v1 => v2 => {
+      if (v2.tag === "Left") { return $0.map(Data$dEither.Left)(v(v2._1)); }
+      if (v2.tag === "Right") { return $0.map(Data$dEither.Right)(v1(v2._1)); }
+      $runtime.fail();
+    };
+  },
+  bisequence: dictApplicative => {
+    const $0 = dictApplicative.Apply0().Functor0();
+    return v => {
+      if (v.tag === "Left") { return $0.map(Data$dEither.Left)(v._1); }
+      if (v.tag === "Right") { return $0.map(Data$dEither.Right)(v._1); }
+      $runtime.fail();
+    };
+  },
+  Bifunctor0: () => Data$dBifunctor.bifunctorEither,
+  Bifoldable1: () => Data$dBifoldable.bifoldableEither
+};
+const bitraversableConst = {
+  bitraverse: dictApplicative => f => v => v1 => dictApplicative.Apply0().Functor0().map(Data$dConst.Const)(f(v1)),
+  bisequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dConst.Const)(v),
+  Bifunctor0: () => Data$dBifunctor.bifunctorConst,
+  Bifoldable1: () => Data$dBifoldable.bifoldableConst
+};
+const bitraversableClown = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const bifunctorClown = {bimap: f => v => v1 => $0.map(f)(v1)};
+  const $1 = dictTraversable.Foldable1();
+  const bifoldableClown = {
+    bifoldr: l => v => u => v1 => $1.foldr(l)(u)(v1),
+    bifoldl: l => v => u => v1 => $1.foldl(l)(u)(v1),
+    bifoldMap: dictMonoid => {
+      const foldMap1 = $1.foldMap(dictMonoid);
+      return l => v => v1 => foldMap1(l)(v1);
+    }
+  };
+  return {
+    bitraverse: dictApplicative => {
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return l => v => v1 => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dClown.Clown)(traverse1(l)(v1));
+    },
+    bisequence: dictApplicative => {
+      const sequence1 = dictTraversable.sequence(dictApplicative);
+      return v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dClown.Clown)(sequence1(v));
+    },
+    Bifunctor0: () => bifunctorClown,
+    Bifoldable1: () => bifoldableClown
+  };
+};
+const bisequenceDefault = dictBitraversable => dictApplicative => dictBitraversable.bitraverse(dictApplicative)(identity)(identity);
+const bisequence = dict => dict.bisequence;
+const bitraversableFlip = dictBitraversable => {
+  const $0 = dictBitraversable.Bifunctor0();
+  const bifunctorFlip = {bimap: f => g => v => $0.bimap(g)(f)(v)};
+  const $1 = dictBitraversable.Bifoldable1();
+  const bifoldableFlip = {
+    bifoldr: r => l => u => v => $1.bifoldr(l)(r)(u)(v),
+    bifoldl: r => l => u => v => $1.bifoldl(l)(r)(u)(v),
+    bifoldMap: dictMonoid => {
+      const bifoldMap2 = $1.bifoldMap(dictMonoid);
+      return r => l => v => bifoldMap2(l)(r)(v);
+    }
+  };
+  return {
+    bitraverse: dictApplicative => {
+      const bitraverse2 = dictBitraversable.bitraverse(dictApplicative);
+      return r => l => v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dFlip.Flip)(bitraverse2(l)(r)(v));
+    },
+    bisequence: dictApplicative => {
+      const bisequence2 = dictBitraversable.bisequence(dictApplicative);
+      return v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dFlip.Flip)(bisequence2(v));
+    },
+    Bifunctor0: () => bifunctorFlip,
+    Bifoldable1: () => bifoldableFlip
+  };
+};
+const bitraversableProduct2 = dictBitraversable => {
+  const $0 = dictBitraversable.Bifunctor0();
+  const bifoldableProduct2 = Data$dBifoldable.bifoldableProduct2(dictBitraversable.Bifoldable1());
+  return dictBitraversable1 => {
+    const $1 = dictBitraversable1.Bifunctor0();
+    const bifunctorProduct21 = {bimap: f => g => v => Data$dFunctor$dProduct2.$Product2($0.bimap(f)(g)(v._1), $1.bimap(f)(g)(v._2))};
+    const bifoldableProduct21 = bifoldableProduct2(dictBitraversable1.Bifoldable1());
+    return {
+      bitraverse: dictApplicative => {
+        const Apply0 = dictApplicative.Apply0();
+        const bitraverse3 = dictBitraversable.bitraverse(dictApplicative);
+        const bitraverse4 = dictBitraversable1.bitraverse(dictApplicative);
+        return l => r => v => Apply0.apply(Apply0.Functor0().map(Data$dFunctor$dProduct2.Product2)(bitraverse3(l)(r)(v._1)))(bitraverse4(l)(r)(v._2));
+      },
+      bisequence: dictApplicative => {
+        const Apply0 = dictApplicative.Apply0();
+        const bisequence3 = dictBitraversable.bisequence(dictApplicative);
+        const bisequence4 = dictBitraversable1.bisequence(dictApplicative);
+        return v => Apply0.apply(Apply0.Functor0().map(Data$dFunctor$dProduct2.Product2)(bisequence3(v._1)))(bisequence4(v._2));
+      },
+      Bifunctor0: () => bifunctorProduct21,
+      Bifoldable1: () => bifoldableProduct21
+    };
+  };
+};
+const bitraverseDefault = dictBitraversable => dictApplicative => {
+  const bisequence2 = dictBitraversable.bisequence(dictApplicative);
+  return f => g => t => bisequence2(dictBitraversable.Bifunctor0().bimap(f)(g)(t));
+};
+const bifor = dictBitraversable => dictApplicative => {
+  const bitraverse2 = dictBitraversable.bitraverse(dictApplicative);
+  return t => f => g => bitraverse2(f)(g)(t);
+};
+export {
+  bifor,
+  bisequence,
+  bisequenceDefault,
+  bitraversableClown,
+  bitraversableConst,
+  bitraversableEither,
+  bitraversableFlip,
+  bitraversableJoker,
+  bitraversableProduct2,
+  bitraversableTuple,
+  bitraverse,
+  bitraverseDefault,
+  identity,
+  lfor,
+  ltraverse,
+  rfor,
+  rtraverse
+};

package/output-es/Data.Boolean/index.js

@@ -0,0 +1,2 @@
+const otherwise = true;
+export {otherwise};

package/output-es/Data.BooleanAlgebra/index.js

@@ -0,0 +1,42 @@
+import * as Data$dHeytingAlgebra from "../Data.HeytingAlgebra/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+const booleanAlgebraUnit = {HeytingAlgebra0: () => Data$dHeytingAlgebra.heytingAlgebraUnit};
+const booleanAlgebraRecordNil = {HeytingAlgebraRecord0: () => Data$dHeytingAlgebra.heytingAlgebraRecordNil};
+const booleanAlgebraRecordCons = dictIsSymbol => () => dictBooleanAlgebraRecord => {
+  const heytingAlgebraRecordCons1 = Data$dHeytingAlgebra.heytingAlgebraRecordCons(dictIsSymbol)()(dictBooleanAlgebraRecord.HeytingAlgebraRecord0());
+  return dictBooleanAlgebra => {
+    const heytingAlgebraRecordCons2 = heytingAlgebraRecordCons1(dictBooleanAlgebra.HeytingAlgebra0());
+    return {HeytingAlgebraRecord0: () => heytingAlgebraRecordCons2};
+  };
+};
+const booleanAlgebraRecord = () => dictBooleanAlgebraRecord => {
+  const $0 = dictBooleanAlgebraRecord.HeytingAlgebraRecord0();
+  const heytingAlgebraRecord1 = {
+    ff: $0.ffRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    tt: $0.ttRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    conj: $0.conjRecord(Type$dProxy.Proxy),
+    disj: $0.disjRecord(Type$dProxy.Proxy),
+    implies: $0.impliesRecord(Type$dProxy.Proxy),
+    not: $0.notRecord(Type$dProxy.Proxy)
+  };
+  return {HeytingAlgebra0: () => heytingAlgebraRecord1};
+};
+const booleanAlgebraProxy = {HeytingAlgebra0: () => Data$dHeytingAlgebra.heytingAlgebraProxy};
+const booleanAlgebraFn = dictBooleanAlgebra => {
+  const $0 = dictBooleanAlgebra.HeytingAlgebra0();
+  const ff1 = $0.ff;
+  const heytingAlgebraFunction = (() => {
+    const tt1 = $0.tt;
+    return {
+      ff: v => ff1,
+      tt: v => tt1,
+      implies: f => g => a => $0.implies(f(a))(g(a)),
+      conj: f => g => a => $0.conj(f(a))(g(a)),
+      disj: f => g => a => $0.disj(f(a))(g(a)),
+      not: f => a => $0.not(f(a))
+    };
+  })();
+  return {HeytingAlgebra0: () => heytingAlgebraFunction};
+};
+const booleanAlgebraBoolean = {HeytingAlgebra0: () => Data$dHeytingAlgebra.heytingAlgebraBoolean};
+export {booleanAlgebraBoolean, booleanAlgebraFn, booleanAlgebraProxy, booleanAlgebraRecord, booleanAlgebraRecordCons, booleanAlgebraRecordNil, booleanAlgebraUnit};

package/output-es/Data.Bounded/foreign.js

@@ -0,0 +1,8 @@
+export const topInt = 2147483647;
+export const bottomInt = -2147483648;
+
+export const topChar = String.fromCharCode(65535);
+export const bottomChar = String.fromCharCode(0);
+
+export const topNumber = Number.POSITIVE_INFINITY;
+export const bottomNumber = Number.NEGATIVE_INFINITY;

package/output-es/Data.Bounded/index.js

@@ -0,0 +1,76 @@
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {bottomChar, bottomInt, bottomNumber, topChar, topInt, topNumber} from "./foreign.js";
+const topRecord = dict => dict.topRecord;
+const top = dict => dict.top;
+const boundedUnit = {top: undefined, bottom: undefined, Ord0: () => Data$dOrd.ordUnit};
+const boundedRecordNil = {topRecord: v => v1 => ({}), bottomRecord: v => v1 => ({}), OrdRecord0: () => Data$dOrd.ordRecordNil};
+const boundedProxy = {bottom: Type$dProxy.Proxy, top: Type$dProxy.Proxy, Ord0: () => Data$dOrd.ordProxy};
+const boundedOrdering = {top: Data$dOrdering.GT, bottom: Data$dOrdering.LT, Ord0: () => Data$dOrd.ordOrdering};
+const boundedNumber = {top: Infinity, bottom: -Infinity, Ord0: () => Data$dOrd.ordNumber};
+const boundedInt = {top: 2147483647, bottom: -2147483648, Ord0: () => Data$dOrd.ordInt};
+const boundedChar = {top: "￿", bottom: "\u0000", Ord0: () => Data$dOrd.ordChar};
+const boundedBoolean = {top: true, bottom: false, Ord0: () => Data$dOrd.ordBoolean};
+const bottomRecord = dict => dict.bottomRecord;
+const boundedRecord = () => dictBoundedRecord => {
+  const $0 = dictBoundedRecord.OrdRecord0();
+  const eqRec1 = {eq: $0.EqRecord0().eqRecord(Type$dProxy.Proxy)};
+  const ordRecord1 = {compare: $0.compareRecord(Type$dProxy.Proxy), Eq0: () => eqRec1};
+  return {
+    top: dictBoundedRecord.topRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    bottom: dictBoundedRecord.bottomRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    Ord0: () => ordRecord1
+  };
+};
+const bottom = dict => dict.bottom;
+const boundedRecordCons = dictIsSymbol => dictBounded => {
+  const top1 = dictBounded.top;
+  const bottom1 = dictBounded.bottom;
+  const Ord0 = dictBounded.Ord0();
+  return () => () => dictBoundedRecord => {
+    const $0 = dictBoundedRecord.OrdRecord0();
+    const $1 = $0.EqRecord0();
+    const $2 = Ord0.Eq0();
+    const ordRecordCons = (() => {
+      const eqRowCons2 = {
+        eqRecord: v => ra => rb => {
+          const $$get = Record$dUnsafe.unsafeGet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy));
+          return $2.eq($$get(ra))($$get(rb)) && $1.eqRecord(Type$dProxy.Proxy)(ra)(rb);
+        }
+      };
+      return {
+        compareRecord: v => ra => rb => {
+          const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+          const left = Ord0.compare(Record$dUnsafe.unsafeGet(key)(ra))(Record$dUnsafe.unsafeGet(key)(rb));
+          if (left === "LT" || left === "GT" || left !== "EQ") { return left; }
+          return $0.compareRecord(Type$dProxy.Proxy)(ra)(rb);
+        },
+        EqRecord0: () => eqRowCons2
+      };
+    })();
+    return {
+      topRecord: v => rowProxy => Record$dUnsafe.unsafeSet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy))(top1)(dictBoundedRecord.topRecord(Type$dProxy.Proxy)(rowProxy)),
+      bottomRecord: v => rowProxy => Record$dUnsafe.unsafeSet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy))(bottom1)(dictBoundedRecord.bottomRecord(Type$dProxy.Proxy)(rowProxy)),
+      OrdRecord0: () => ordRecordCons
+    };
+  };
+};
+export {
+  bottom,
+  bottomRecord,
+  boundedBoolean,
+  boundedChar,
+  boundedInt,
+  boundedNumber,
+  boundedOrdering,
+  boundedProxy,
+  boundedRecord,
+  boundedRecordCons,
+  boundedRecordNil,
+  boundedUnit,
+  top,
+  topRecord
+};
+export * from "./foreign.js";

package/output-es/Data.Bounded.Generic/index.js

@@ -0,0 +1,37 @@
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+const genericTopNoArguments = {"genericTop'": Data$dGeneric$dRep.NoArguments};
+const genericTopArgument = dictBounded => ({"genericTop'": dictBounded.top});
+const genericTop$p = dict => dict["genericTop'"];
+const genericTopConstructor = dictGenericTop => ({"genericTop'": dictGenericTop["genericTop'"]});
+const genericTopProduct = dictGenericTop => {
+  const genericTop$p1 = dictGenericTop["genericTop'"];
+  return dictGenericTop1 => ({"genericTop'": Data$dGeneric$dRep.$Product(genericTop$p1, dictGenericTop1["genericTop'"])});
+};
+const genericTopSum = dictGenericTop => ({"genericTop'": Data$dGeneric$dRep.$Sum("Inr", dictGenericTop["genericTop'"])});
+const genericTop = dictGeneric => dictGenericTop => dictGeneric.to(dictGenericTop["genericTop'"]);
+const genericBottomNoArguments = {"genericBottom'": Data$dGeneric$dRep.NoArguments};
+const genericBottomArgument = dictBounded => ({"genericBottom'": dictBounded.bottom});
+const genericBottom$p = dict => dict["genericBottom'"];
+const genericBottomConstructor = dictGenericBottom => ({"genericBottom'": dictGenericBottom["genericBottom'"]});
+const genericBottomProduct = dictGenericBottom => {
+  const genericBottom$p1 = dictGenericBottom["genericBottom'"];
+  return dictGenericBottom1 => ({"genericBottom'": Data$dGeneric$dRep.$Product(genericBottom$p1, dictGenericBottom1["genericBottom'"])});
+};
+const genericBottomSum = dictGenericBottom => ({"genericBottom'": Data$dGeneric$dRep.$Sum("Inl", dictGenericBottom["genericBottom'"])});
+const genericBottom = dictGeneric => dictGenericBottom => dictGeneric.to(dictGenericBottom["genericBottom'"]);
+export {
+  genericBottom,
+  genericBottom$p,
+  genericBottomArgument,
+  genericBottomConstructor,
+  genericBottomNoArguments,
+  genericBottomProduct,
+  genericBottomSum,
+  genericTop,
+  genericTop$p,
+  genericTopArgument,
+  genericTopConstructor,
+  genericTopNoArguments,
+  genericTopProduct,
+  genericTopSum
+};