@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,194 @@
+// | A data type and functions for working with ordered pairs.
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const $Tuple = (_1, _2) => ({tag: "Tuple", _1, _2});
+const Tuple = value0 => value1 => $Tuple(value0, value1);
+const uncurry = f => v => f(v._1)(v._2);
+const swap = v => $Tuple(v._2, v._1);
+const snd = v => v._2;
+const showTuple = dictShow => dictShow1 => ({show: v => "(Tuple " + dictShow.show(v._1) + " " + dictShow1.show(v._2) + ")"});
+const semiringTuple = dictSemiring => {
+  const one = dictSemiring.one;
+  const zero = dictSemiring.zero;
+  return dictSemiring1 => (
+    {
+      add: v => v1 => $Tuple(dictSemiring.add(v._1)(v1._1), dictSemiring1.add(v._2)(v1._2)),
+      one: $Tuple(one, dictSemiring1.one),
+      mul: v => v1 => $Tuple(dictSemiring.mul(v._1)(v1._1), dictSemiring1.mul(v._2)(v1._2)),
+      zero: $Tuple(zero, dictSemiring1.zero)
+    }
+  );
+};
+const semigroupoidTuple = {compose: v => v1 => $Tuple(v1._1, v._2)};
+const semigroupTuple = dictSemigroup => dictSemigroup1 => ({append: v => v1 => $Tuple(dictSemigroup.append(v._1)(v1._1), dictSemigroup1.append(v._2)(v1._2))});
+const ringTuple = dictRing => {
+  const $0 = dictRing.Semiring0();
+  const one = $0.one;
+  const semiringTuple1 = (() => {
+    const zero = $0.zero;
+    return dictSemiring1 => (
+      {
+        add: v => v1 => $Tuple($0.add(v._1)(v1._1), dictSemiring1.add(v._2)(v1._2)),
+        one: $Tuple(one, dictSemiring1.one),
+        mul: v => v1 => $Tuple($0.mul(v._1)(v1._1), dictSemiring1.mul(v._2)(v1._2)),
+        zero: $Tuple(zero, dictSemiring1.zero)
+      }
+    );
+  })();
+  return dictRing1 => {
+    const semiringTuple2 = semiringTuple1(dictRing1.Semiring0());
+    return {sub: v => v1 => $Tuple(dictRing.sub(v._1)(v1._1), dictRing1.sub(v._2)(v1._2)), Semiring0: () => semiringTuple2};
+  };
+};
+const monoidTuple = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const $0 = dictMonoid.Semigroup0();
+  return dictMonoid1 => {
+    const $1 = dictMonoid1.Semigroup0();
+    const semigroupTuple2 = {append: v => v1 => $Tuple($0.append(v._1)(v1._1), $1.append(v._2)(v1._2))};
+    return {mempty: $Tuple(mempty, dictMonoid1.mempty), Semigroup0: () => semigroupTuple2};
+  };
+};
+const heytingAlgebraTuple = dictHeytingAlgebra => {
+  const tt = dictHeytingAlgebra.tt;
+  const ff = dictHeytingAlgebra.ff;
+  return dictHeytingAlgebra1 => (
+    {
+      tt: $Tuple(tt, dictHeytingAlgebra1.tt),
+      ff: $Tuple(ff, dictHeytingAlgebra1.ff),
+      implies: v => v1 => $Tuple(dictHeytingAlgebra.implies(v._1)(v1._1), dictHeytingAlgebra1.implies(v._2)(v1._2)),
+      conj: v => v1 => $Tuple(dictHeytingAlgebra.conj(v._1)(v1._1), dictHeytingAlgebra1.conj(v._2)(v1._2)),
+      disj: v => v1 => $Tuple(dictHeytingAlgebra.disj(v._1)(v1._1), dictHeytingAlgebra1.disj(v._2)(v1._2)),
+      not: v => $Tuple(dictHeytingAlgebra.not(v._1), dictHeytingAlgebra1.not(v._2))
+    }
+  );
+};
+const genericTuple = {to: x => $Tuple(x._1, x._2), from: x => Data$dGeneric$dRep.$Product(x._1, x._2)};
+const functorTuple = {map: f => m => $Tuple(m._1, f(m._2))};
+const invariantTuple = {imap: f => v => m => $Tuple(m._1, f(m._2))};
+const fst = v => v._1;
+const lazyTuple = dictLazy => dictLazy1 => ({defer: f => $Tuple(dictLazy.defer(v => f()._1), dictLazy1.defer(v => f()._2))});
+const extendTuple = {extend: f => v => $Tuple(v._1, f(v)), Functor0: () => functorTuple};
+const eqTuple = dictEq => dictEq1 => ({eq: x => y => dictEq.eq(x._1)(y._1) && dictEq1.eq(x._2)(y._2)});
+const ordTuple = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  return dictOrd1 => {
+    const $1 = dictOrd1.Eq0();
+    const eqTuple2 = {eq: x => y => $0.eq(x._1)(y._1) && $1.eq(x._2)(y._2)};
+    return {
+      compare: x => y => {
+        const v = dictOrd.compare(x._1)(y._1);
+        if (v === "LT") { return Data$dOrdering.LT; }
+        if (v === "GT") { return Data$dOrdering.GT; }
+        return dictOrd1.compare(x._2)(y._2);
+      },
+      Eq0: () => eqTuple2
+    };
+  };
+};
+const eq1Tuple = dictEq => ({eq1: dictEq1 => x => y => dictEq.eq(x._1)(y._1) && dictEq1.eq(x._2)(y._2)});
+const ord1Tuple = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  const eq1Tuple1 = {eq1: dictEq1 => x => y => $0.eq(x._1)(y._1) && dictEq1.eq(x._2)(y._2)};
+  return {
+    compare1: dictOrd1 => x => y => {
+      const v = dictOrd.compare(x._1)(y._1);
+      if (v === "LT") { return Data$dOrdering.LT; }
+      if (v === "GT") { return Data$dOrdering.GT; }
+      return dictOrd1.compare(x._2)(y._2);
+    },
+    Eq10: () => eq1Tuple1
+  };
+};
+const curry = f => a => b => f($Tuple(a, b));
+const comonadTuple = {extract: snd, Extend0: () => extendTuple};
+const commutativeRingTuple = dictCommutativeRing => {
+  const ringTuple1 = ringTuple(dictCommutativeRing.Ring0());
+  return dictCommutativeRing1 => {
+    const ringTuple2 = ringTuple1(dictCommutativeRing1.Ring0());
+    return {Ring0: () => ringTuple2};
+  };
+};
+const boundedTuple = dictBounded => {
+  const top = dictBounded.top;
+  const bottom = dictBounded.bottom;
+  const $0 = dictBounded.Ord0();
+  const $1 = $0.Eq0();
+  return dictBounded1 => {
+    const $2 = dictBounded1.Ord0();
+    const $3 = $2.Eq0();
+    const ordTuple2 = (() => {
+      const eqTuple2 = {eq: x => y => $1.eq(x._1)(y._1) && $3.eq(x._2)(y._2)};
+      return {
+        compare: x => y => {
+          const v = $0.compare(x._1)(y._1);
+          if (v === "LT") { return Data$dOrdering.LT; }
+          if (v === "GT") { return Data$dOrdering.GT; }
+          return $2.compare(x._2)(y._2);
+        },
+        Eq0: () => eqTuple2
+      };
+    })();
+    return {top: $Tuple(top, dictBounded1.top), bottom: $Tuple(bottom, dictBounded1.bottom), Ord0: () => ordTuple2};
+  };
+};
+const booleanAlgebraTuple = dictBooleanAlgebra => {
+  const heytingAlgebraTuple1 = heytingAlgebraTuple(dictBooleanAlgebra.HeytingAlgebra0());
+  return dictBooleanAlgebra1 => {
+    const heytingAlgebraTuple2 = heytingAlgebraTuple1(dictBooleanAlgebra1.HeytingAlgebra0());
+    return {HeytingAlgebra0: () => heytingAlgebraTuple2};
+  };
+};
+const applyTuple = dictSemigroup => ({apply: v => v1 => $Tuple(dictSemigroup.append(v._1)(v1._1), v._2(v1._2)), Functor0: () => functorTuple});
+const bindTuple = dictSemigroup => {
+  const applyTuple1 = applyTuple(dictSemigroup);
+  return {
+    bind: v => f => {
+      const v1 = f(v._2);
+      return $Tuple(dictSemigroup.append(v._1)(v1._1), v1._2);
+    },
+    Apply0: () => applyTuple1
+  };
+};
+const applicativeTuple = dictMonoid => {
+  const applyTuple1 = applyTuple(dictMonoid.Semigroup0());
+  return {pure: Tuple(dictMonoid.mempty), Apply0: () => applyTuple1};
+};
+const monadTuple = dictMonoid => {
+  const applicativeTuple1 = applicativeTuple(dictMonoid);
+  const bindTuple1 = bindTuple(dictMonoid.Semigroup0());
+  return {Applicative0: () => applicativeTuple1, Bind1: () => bindTuple1};
+};
+export {
+  $Tuple,
+  Tuple,
+  applicativeTuple,
+  applyTuple,
+  bindTuple,
+  booleanAlgebraTuple,
+  boundedTuple,
+  commutativeRingTuple,
+  comonadTuple,
+  curry,
+  eq1Tuple,
+  eqTuple,
+  extendTuple,
+  fst,
+  functorTuple,
+  genericTuple,
+  heytingAlgebraTuple,
+  invariantTuple,
+  lazyTuple,
+  monadTuple,
+  monoidTuple,
+  ord1Tuple,
+  ordTuple,
+  ringTuple,
+  semigroupTuple,
+  semigroupoidTuple,
+  semiringTuple,
+  showTuple,
+  snd,
+  swap,
+  uncurry
+};

package/output-es/Data.Tuple.Nested/index.js

@@ -0,0 +1,290 @@
+// | Tuples that are not restricted to two elements.
+// |
+// | Here is an example of a 3-tuple:
+// |
+// | 
+// | ```purescript
+// | > tuple = tuple3 1 "2" 3.0
+// | > tuple
+// | (Tuple 1 (Tuple "2" (Tuple 3.0 unit)))
+// | ```
+// | 
+// | Notice that a tuple is a nested structure not unlike a list. The type of `tuple` is this:
+// | 
+// | ```purescript
+// | > :t tuple
+// | Tuple Int (Tuple String (Tuple Number Unit))
+// | ```
+// | 
+// | That, however, can be abbreviated with the `Tuple3` type:
+// | 
+// | ```purescript
+// | Tuple3 Int String Number
+// | ```
+// |
+// | All tuple functions are numbered from 1 to 10. That is, there's
+// | a `get1` and a `get10`.
+// |
+// | The `getN` functions accept tuples of length N or greater:
+// | 
+// | ```purescript
+// | get1 tuple = 1
+// | get3 tuple = 3
+// | get4 tuple -- type error. `get4` requires a longer tuple. 
+// | ```
+// | 
+// | The same is true of the `overN` functions:
+// | 
+// | ```purescript
+// | over2 negate (tuple3 1 2 3) = tuple3 1 (-2) 3
+// | ```
+// |
+// | `uncurryN` can be used to convert a function that takes `N` arguments to one that takes an N-tuple:
+// | 
+// | ```purescript
+// | uncurry2 (+) (tuple2 1 2) = 3
+// | ```
+// | 
+// | The reverse `curryN` function converts functions that take
+// | N-tuples (which are rare) to functions that take `N` arguments.
+// |
+// | ---------------
+// | In addition to types like `Tuple3`, there are also types like
+// | `T3`. Whereas `Tuple3` describes a tuple with exactly three
+// | elements, `T3` describes a tuple of length *two or longer*. More
+// | specifically, `T3` requires two element plus a "tail" that may be
+// | `unit` or more tuple elements. Use types like `T3` when you want to
+// | create a set of functions for arbitrary tuples. See the source for how that's done.
+// | 
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const uncurry9 = f$p => v => f$p(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1)(v._2._2._2._2._1)(v._2._2._2._2._2._1)(v._2._2._2._2._2._2._1)(v._2._2._2._2._2._2._2._1)(v._2._2._2._2._2._2._2._2._1);
+const uncurry8 = f$p => v => f$p(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1)(v._2._2._2._2._1)(v._2._2._2._2._2._1)(v._2._2._2._2._2._2._1)(v._2._2._2._2._2._2._2._1);
+const uncurry7 = f$p => v => f$p(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1)(v._2._2._2._2._1)(v._2._2._2._2._2._1)(v._2._2._2._2._2._2._1);
+const uncurry6 = f$p => v => f$p(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1)(v._2._2._2._2._1)(v._2._2._2._2._2._1);
+const uncurry5 = f => v => f(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1)(v._2._2._2._2._1);
+const uncurry4 = f => v => f(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1);
+const uncurry3 = f => v => f(v._1)(v._2._1)(v._2._2._1);
+const uncurry2 = f => v => f(v._1)(v._2._1);
+const uncurry10 = f$p => v => f$p(v._1)(v._2._1)(v._2._2._1)(v._2._2._2._1)(v._2._2._2._2._1)(v._2._2._2._2._2._1)(v._2._2._2._2._2._2._1)(v._2._2._2._2._2._2._2._1)(v._2._2._2._2._2._2._2._2._1)(v._2._2._2._2._2._2._2._2._2._1);
+const uncurry1 = f => v => f(v._1);
+const tuple9 = a => b => c => d => e => f => g => h => i => Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(
+    b,
+    Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, Data$dTuple.$Tuple(h, Data$dTuple.$Tuple(i, undefined)))))))
+  )
+);
+const tuple8 = a => b => c => d => e => f => g => h => Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, Data$dTuple.$Tuple(h, undefined)))))))
+);
+const tuple7 = a => b => c => d => e => f => g => Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, undefined))))))
+);
+const tuple6 = a => b => c => d => e => f => Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, undefined)))))
+);
+const tuple5 = a => b => c => d => e => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, undefined)))));
+const tuple4 = a => b => c => d => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, undefined))));
+const tuple3 = a => b => c => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, undefined)));
+const tuple2 = a => b => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, undefined));
+const tuple10 = a => b => c => d => e => f => g => h => i => j => Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(
+    b,
+    Data$dTuple.$Tuple(
+      c,
+      Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, Data$dTuple.$Tuple(h, Data$dTuple.$Tuple(i, Data$dTuple.$Tuple(j, undefined)))))))
+    )
+  )
+);
+const tuple1 = a => Data$dTuple.$Tuple(a, undefined);
+const over9 = o => v => Data$dTuple.$Tuple(
+  v._1,
+  Data$dTuple.$Tuple(
+    v._2._1,
+    Data$dTuple.$Tuple(
+      v._2._2._1,
+      Data$dTuple.$Tuple(
+        v._2._2._2._1,
+        Data$dTuple.$Tuple(
+          v._2._2._2._2._1,
+          Data$dTuple.$Tuple(
+            v._2._2._2._2._2._1,
+            Data$dTuple.$Tuple(
+              v._2._2._2._2._2._2._1,
+              Data$dTuple.$Tuple(v._2._2._2._2._2._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._2._2._2._2._2._1), v._2._2._2._2._2._2._2._2._2))
+            )
+          )
+        )
+      )
+    )
+  )
+);
+const over8 = o => v => Data$dTuple.$Tuple(
+  v._1,
+  Data$dTuple.$Tuple(
+    v._2._1,
+    Data$dTuple.$Tuple(
+      v._2._2._1,
+      Data$dTuple.$Tuple(
+        v._2._2._2._1,
+        Data$dTuple.$Tuple(
+          v._2._2._2._2._1,
+          Data$dTuple.$Tuple(v._2._2._2._2._2._1, Data$dTuple.$Tuple(v._2._2._2._2._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._2._2._2._2._1), v._2._2._2._2._2._2._2._2)))
+        )
+      )
+    )
+  )
+);
+const over7 = o => v => Data$dTuple.$Tuple(
+  v._1,
+  Data$dTuple.$Tuple(
+    v._2._1,
+    Data$dTuple.$Tuple(
+      v._2._2._1,
+      Data$dTuple.$Tuple(
+        v._2._2._2._1,
+        Data$dTuple.$Tuple(v._2._2._2._2._1, Data$dTuple.$Tuple(v._2._2._2._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._2._2._2._1), v._2._2._2._2._2._2._2)))
+      )
+    )
+  )
+);
+const over6 = o => v => Data$dTuple.$Tuple(
+  v._1,
+  Data$dTuple.$Tuple(
+    v._2._1,
+    Data$dTuple.$Tuple(v._2._2._1, Data$dTuple.$Tuple(v._2._2._2._1, Data$dTuple.$Tuple(v._2._2._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._2._2._1), v._2._2._2._2._2._2))))
+  )
+);
+const over5 = o => v => Data$dTuple.$Tuple(
+  v._1,
+  Data$dTuple.$Tuple(v._2._1, Data$dTuple.$Tuple(v._2._2._1, Data$dTuple.$Tuple(v._2._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._2._1), v._2._2._2._2._2))))
+);
+const over4 = o => v => Data$dTuple.$Tuple(v._1, Data$dTuple.$Tuple(v._2._1, Data$dTuple.$Tuple(v._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._1), v._2._2._2._2))));
+const over3 = o => v => Data$dTuple.$Tuple(v._1, Data$dTuple.$Tuple(v._2._1, Data$dTuple.$Tuple(o(v._2._2._1), v._2._2._2)));
+const over2 = o => v => Data$dTuple.$Tuple(v._1, Data$dTuple.$Tuple(o(v._2._1), v._2._2));
+const over10 = o => v => Data$dTuple.$Tuple(
+  v._1,
+  Data$dTuple.$Tuple(
+    v._2._1,
+    Data$dTuple.$Tuple(
+      v._2._2._1,
+      Data$dTuple.$Tuple(
+        v._2._2._2._1,
+        Data$dTuple.$Tuple(
+          v._2._2._2._2._1,
+          Data$dTuple.$Tuple(
+            v._2._2._2._2._2._1,
+            Data$dTuple.$Tuple(
+              v._2._2._2._2._2._2._1,
+              Data$dTuple.$Tuple(
+                v._2._2._2._2._2._2._2._1,
+                Data$dTuple.$Tuple(v._2._2._2._2._2._2._2._2._1, Data$dTuple.$Tuple(o(v._2._2._2._2._2._2._2._2._2._1), v._2._2._2._2._2._2._2._2._2._2))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+);
+const over1 = o => v => Data$dTuple.$Tuple(o(v._1), v._2);
+const get9 = v => v._2._2._2._2._2._2._2._2._1;
+const get8 = v => v._2._2._2._2._2._2._2._1;
+const get7 = v => v._2._2._2._2._2._2._1;
+const get6 = v => v._2._2._2._2._2._1;
+const get5 = v => v._2._2._2._2._1;
+const get4 = v => v._2._2._2._1;
+const get3 = v => v._2._2._1;
+const get2 = v => v._2._1;
+const get10 = v => v._2._2._2._2._2._2._2._2._2._1;
+const get1 = v => v._1;
+const curry9 = z => f$p => a => b => c => d => e => f => g => h => i => f$p(Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(
+    b,
+    Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, Data$dTuple.$Tuple(h, Data$dTuple.$Tuple(i, z)))))))
+  )
+));
+const curry8 = z => f$p => a => b => c => d => e => f => g => h => f$p(Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, Data$dTuple.$Tuple(h, z)))))))
+));
+const curry7 = z => f$p => a => b => c => d => e => f => g => f$p(Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, z))))))
+));
+const curry6 = z => f$p => a => b => c => d => e => f => f$p(Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, z)))))
+));
+const curry5 = z => f => a => b => c => d => e => f(Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, z))))));
+const curry4 = z => f => a => b => c => d => f(Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, z)))));
+const curry3 = z => f => a => b => c => f(Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, z))));
+const curry2 = z => f => a => b => f(Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, z)));
+const curry10 = z => f$p => a => b => c => d => e => f => g => h => i => j => f$p(Data$dTuple.$Tuple(
+  a,
+  Data$dTuple.$Tuple(
+    b,
+    Data$dTuple.$Tuple(
+      c,
+      Data$dTuple.$Tuple(d, Data$dTuple.$Tuple(e, Data$dTuple.$Tuple(f, Data$dTuple.$Tuple(g, Data$dTuple.$Tuple(h, Data$dTuple.$Tuple(i, Data$dTuple.$Tuple(j, z)))))))
+    )
+  )
+));
+const curry1 = z => f => a => f(Data$dTuple.$Tuple(a, z));
+export {
+  curry1,
+  curry10,
+  curry2,
+  curry3,
+  curry4,
+  curry5,
+  curry6,
+  curry7,
+  curry8,
+  curry9,
+  get1,
+  get10,
+  get2,
+  get3,
+  get4,
+  get5,
+  get6,
+  get7,
+  get8,
+  get9,
+  over1,
+  over10,
+  over2,
+  over3,
+  over4,
+  over5,
+  over6,
+  over7,
+  over8,
+  over9,
+  tuple1,
+  tuple10,
+  tuple2,
+  tuple3,
+  tuple4,
+  tuple5,
+  tuple6,
+  tuple7,
+  tuple8,
+  tuple9,
+  uncurry1,
+  uncurry10,
+  uncurry2,
+  uncurry3,
+  uncurry4,
+  uncurry5,
+  uncurry6,
+  uncurry7,
+  uncurry8,
+  uncurry9
+};

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

@@ -0,0 +1,21 @@
+export const unfoldrArrayImpl = function (isNothing) {
+  return function (fromJust) {
+    return function (fst) {
+      return function (snd) {
+        return function (f) {
+          return function (b) {
+            var result = [];
+            var value = b;
+            while (true) { // eslint-disable-line no-constant-condition
+              var maybe = f(value);
+              if (isNothing(maybe)) return result;
+              var tuple = fromJust(maybe);
+              result.push(fst(tuple));
+              value = snd(tuple);
+            }
+          };
+        };
+      };
+    };
+  };
+};

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

@@ -0,0 +1,45 @@
+// | This module provides a type class for _unfoldable functors_, i.e.
+// | functors which support an `unfoldr` operation.
+// |
+// | This allows us to unify various operations on arrays, lists,
+// | sequences, etc.
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Data$dUnfoldable1 from "../Data.Unfoldable1/index.js";
+import {unfoldrArrayImpl} from "./foreign.js";
+const fromJust = v => {
+  if (v.tag === "Just") { return v._1; }
+  $runtime.fail();
+};
+const unfoldr = dict => dict.unfoldr;
+const unfoldableMaybe = {
+  unfoldr: f => b => {
+    const $0 = f(b);
+    if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0._1._1); }
+    return Data$dMaybe.Nothing;
+  },
+  Unfoldable10: () => Data$dUnfoldable1.unfoldable1Maybe
+};
+const unfoldableArray = {
+  unfoldr: /* #__PURE__ */ unfoldrArrayImpl(Data$dMaybe.isNothing)(fromJust)(Data$dTuple.fst)(Data$dTuple.snd),
+  Unfoldable10: () => Data$dUnfoldable1.unfoldable1Array
+};
+const replicate = dictUnfoldable => n => v => dictUnfoldable.unfoldr(i => {
+  if (i <= 0) { return Data$dMaybe.Nothing; }
+  return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(v, i - 1 | 0));
+})(n);
+const replicateA = dictApplicative => dictUnfoldable => dictTraversable => {
+  const sequence = dictTraversable.sequence(dictApplicative);
+  return n => m => sequence(dictUnfoldable.unfoldr(i => {
+    if (i <= 0) { return Data$dMaybe.Nothing; }
+    return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(m, i - 1 | 0));
+  })(n));
+};
+const none = dictUnfoldable => dictUnfoldable.unfoldr(v => Data$dMaybe.Nothing)();
+const fromMaybe = dictUnfoldable => dictUnfoldable.unfoldr(b => {
+  if (b.tag === "Just") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(b._1, Data$dMaybe.Nothing)); }
+  return Data$dMaybe.Nothing;
+});
+export {fromJust, fromMaybe, none, replicate, replicateA, unfoldableArray, unfoldableMaybe, unfoldr};
+export * from "./foreign.js";

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

@@ -0,0 +1,21 @@
+export const unfoldr1ArrayImpl = function (isNothing) {
+  return function (fromJust) {
+    return function (fst) {
+      return function (snd) {
+        return function (f) {
+          return function (b) {
+            var result = [];
+            var value = b;
+            while (true) { // eslint-disable-line no-constant-condition
+              var tuple = f(value);
+              result.push(fst(tuple));
+              var maybe = snd(tuple);
+              if (isNothing(maybe)) return result;
+              value = fromJust(maybe);
+            }
+          };
+        };
+      };
+    };
+  };
+};

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

@@ -0,0 +1,39 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import {unfoldr1ArrayImpl} from "./foreign.js";
+const fromJust = v => {
+  if (v.tag === "Just") { return v._1; }
+  $runtime.fail();
+};
+const unfoldr1 = dict => dict.unfoldr1;
+const unfoldable1Maybe = {unfoldr1: f => b => Data$dMaybe.$Maybe("Just", f(b)._1)};
+const unfoldable1Array = {unfoldr1: /* #__PURE__ */ unfoldr1ArrayImpl(Data$dMaybe.isNothing)(fromJust)(Data$dTuple.fst)(Data$dTuple.snd)};
+const replicate1 = dictUnfoldable1 => n => v => dictUnfoldable1.unfoldr1(i => {
+  if (i <= 0) { return Data$dTuple.$Tuple(v, Data$dMaybe.Nothing); }
+  return Data$dTuple.$Tuple(v, Data$dMaybe.$Maybe("Just", i - 1 | 0));
+})(n - 1 | 0);
+const replicate1A = dictApply => dictUnfoldable1 => dictTraversable1 => {
+  const sequence1 = dictTraversable1.sequence1(dictApply);
+  return n => m => sequence1(dictUnfoldable1.unfoldr1(i => {
+    if (i <= 0) { return Data$dTuple.$Tuple(m, Data$dMaybe.Nothing); }
+    return Data$dTuple.$Tuple(m, Data$dMaybe.$Maybe("Just", i - 1 | 0));
+  })(n - 1 | 0));
+};
+const singleton = dictUnfoldable1 => v => dictUnfoldable1.unfoldr1(i => {
+  if (i <= 0) { return Data$dTuple.$Tuple(v, Data$dMaybe.Nothing); }
+  return Data$dTuple.$Tuple(v, Data$dMaybe.$Maybe("Just", i - 1 | 0));
+})(0);
+const range = dictUnfoldable1 => start => end => dictUnfoldable1.unfoldr1((() => {
+  const $0 = end >= start ? 1 : -1;
+  return i => {
+    const i$p = i + $0 | 0;
+    return Data$dTuple.$Tuple(i, i === end ? Data$dMaybe.Nothing : Data$dMaybe.$Maybe("Just", i$p));
+  };
+})())(start);
+const iterateN = dictUnfoldable1 => n => f => s => dictUnfoldable1.unfoldr1(v => Data$dTuple.$Tuple(
+  v._1,
+  v._2 > 0 ? Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(f(v._1), v._2 - 1 | 0)) : Data$dMaybe.Nothing
+))(Data$dTuple.$Tuple(s, n - 1 | 0));
+export {fromJust, iterateN, range, replicate1, replicate1A, singleton, unfoldable1Array, unfoldable1Maybe, unfoldr1};
+export * from "./foreign.js";

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

@@ -0,0 +1 @@
+export const unit = undefined;

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

@@ -0,0 +1,3 @@
+import {unit} from "./foreign.js";
+export {};
+export * from "./foreign.js";

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

@@ -0,0 +1,12 @@
+const absurd = a => {
+  const spin = spin$a0$copy => {
+    let spin$a0 = spin$a0$copy, spin$c = true, spin$r;
+    while (spin$c) {
+      const v = spin$a0;
+      spin$a0 = v;
+    }
+    return spin$r;
+  };
+  return spin(a);
+};
+export {absurd};