@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,49 @@
+import * as Data$dRing from "../Data.Ring/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+const commutativeRingUnit = {Ring0: () => Data$dRing.ringUnit};
+const commutativeRingRecordNil = {RingRecord0: () => Data$dRing.ringRecordNil};
+const commutativeRingRecordCons = dictIsSymbol => () => dictCommutativeRingRecord => {
+  const ringRecordCons1 = Data$dRing.ringRecordCons(dictIsSymbol)()(dictCommutativeRingRecord.RingRecord0());
+  return dictCommutativeRing => {
+    const ringRecordCons2 = ringRecordCons1(dictCommutativeRing.Ring0());
+    return {RingRecord0: () => ringRecordCons2};
+  };
+};
+const commutativeRingRecord = () => dictCommutativeRingRecord => {
+  const $0 = dictCommutativeRingRecord.RingRecord0();
+  const $1 = $0.SemiringRecord0();
+  const ringRecord1 = (() => {
+    const semiringRecord1 = {
+      add: $1.addRecord(Type$dProxy.Proxy),
+      mul: $1.mulRecord(Type$dProxy.Proxy),
+      one: $1.oneRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+      zero: $1.zeroRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy)
+    };
+    return {sub: $0.subRecord(Type$dProxy.Proxy), Semiring0: () => semiringRecord1};
+  })();
+  return {Ring0: () => ringRecord1};
+};
+const commutativeRingProxy = {Ring0: () => Data$dRing.ringProxy};
+const commutativeRingNumber = {Ring0: () => Data$dRing.ringNumber};
+const commutativeRingInt = {Ring0: () => Data$dRing.ringInt};
+const commutativeRingFn = dictCommutativeRing => {
+  const $0 = dictCommutativeRing.Ring0();
+  const $1 = $0.Semiring0();
+  const ringFn = (() => {
+    const zero1 = $1.zero;
+    const one1 = $1.one;
+    const semiringFn = {add: f => g => x => $1.add(f(x))(g(x)), zero: v => zero1, mul: f => g => x => $1.mul(f(x))(g(x)), one: v => one1};
+    return {sub: f => g => x => $0.sub(f(x))(g(x)), Semiring0: () => semiringFn};
+  })();
+  return {Ring0: () => ringFn};
+};
+export {
+  commutativeRingFn,
+  commutativeRingInt,
+  commutativeRingNumber,
+  commutativeRingProxy,
+  commutativeRingRecord,
+  commutativeRingRecordCons,
+  commutativeRingRecordNil,
+  commutativeRingUnit
+};

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

@@ -0,0 +1,228 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dArray$dST$dIterator from "../Data.Array.ST.Iterator/index.js";
+import * as Data$dEither from "../Data.Either/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$dMaybe from "../Data.Maybe/index.js";
+const toUnfoldable = x => {
+  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 source = go$a0, memo = go$a1;
+      const v = Data$dMap$dInternal.stepUnfoldr(source);
+      if (v.tag === "Nothing") {
+        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$1 = go$1$a1;
+            if (v$1.tag === "Nil") {
+              go$1$c = false;
+              go$1$r = b;
+              continue;
+            }
+            if (v$1.tag === "Cons") {
+              go$1$a0 = Data$dList$dTypes.$List("Cons", v$1._1, b);
+              go$1$a1 = v$1._2;
+              continue;
+            }
+            $runtime.fail();
+          }
+          return go$1$r;
+        };
+        go$c = false;
+        go$r = go$1(Data$dList$dTypes.Nil)(memo);
+        continue;
+      }
+      if (v.tag === "Just") {
+        go$a0 = v._1._2;
+        go$a1 = Data$dList$dTypes.$List("Cons", v._1._1, memo);
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(Data$dMap$dInternal.$MapIter("IterNode", x, Data$dMap$dInternal.IterLeaf))(Data$dList$dTypes.Nil);
+};
+const separate = dict => dict.separate;
+const compactableMaybe = {
+  compact: m => {
+    if (m.tag === "Just") { return m._1; }
+    if (m.tag === "Nothing") { return Data$dMaybe.Nothing; }
+    $runtime.fail();
+  },
+  separate: v => {
+    if (v.tag === "Nothing") { return {left: Data$dMaybe.Nothing, right: Data$dMaybe.Nothing}; }
+    if (v.tag === "Just") {
+      if (v._1.tag === "Left") { return {left: Data$dMaybe.$Maybe("Just", v._1._1), right: Data$dMaybe.Nothing}; }
+      if (v._1.tag === "Right") { return {left: Data$dMaybe.Nothing, right: Data$dMaybe.$Maybe("Just", v._1._1)}; }
+    }
+    $runtime.fail();
+  }
+};
+const compactableMap = dictOrd => {
+  const alter = Data$dMap$dInternal.alter(dictOrd);
+  return {
+    compact: (() => {
+      const $0 = Data$dList$dTypes.foldableList.foldr(v => m => {
+        const $0 = v._2;
+        return alter(v$1 => $0)(v._1)(m);
+      })(Data$dMap$dInternal.Leaf);
+      return x => $0(toUnfoldable(x));
+    })(),
+    separate: (() => {
+      const $0 = Data$dList$dTypes.foldableList.foldr(v => v1 => {
+        if (v._2.tag === "Left") { return {left: Data$dMap$dInternal.insert(dictOrd)(v._1)(v._2._1)(v1.left), right: v1.right}; }
+        if (v._2.tag === "Right") { return {left: v1.left, right: Data$dMap$dInternal.insert(dictOrd)(v._1)(v._2._1)(v1.right)}; }
+        $runtime.fail();
+      })({left: Data$dMap$dInternal.Leaf, right: Data$dMap$dInternal.Leaf});
+      return x => $0(toUnfoldable(x));
+    })()
+  };
+};
+const compactableList = {
+  compact: Data$dList.catMaybes,
+  separate: /* #__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 = (() => {
+            if (v._1.tag === "Left") {
+              return {left: Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(Data$dList$dTypes.$List("Cons", v._1._1, Data$dList$dTypes.Nil))(b.left), right: b.right};
+            }
+            if (v._1.tag === "Right") {
+              return {right: Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(Data$dList$dTypes.$List("Cons", v._1._1, Data$dList$dTypes.Nil))(b.right), left: b.left};
+            }
+            $runtime.fail();
+          })();
+          go$a1 = v._2;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go({left: Data$dList$dTypes.Nil, right: Data$dList$dTypes.Nil});
+  })()
+};
+const compactableEither = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return {
+    compact: v => {
+      if (v.tag === "Left") { return Data$dEither.$Either("Left", v._1); }
+      if (v.tag === "Right") {
+        if (v._1.tag === "Just") { return Data$dEither.$Either("Right", v._1._1); }
+        if (v._1.tag === "Nothing") { return Data$dEither.$Either("Left", mempty); }
+      }
+      $runtime.fail();
+    },
+    separate: v => {
+      if (v.tag === "Left") { return {left: Data$dEither.$Either("Left", v._1), right: Data$dEither.$Either("Left", v._1)}; }
+      if (v.tag === "Right") {
+        if (v._1.tag === "Left") { return {left: Data$dEither.$Either("Right", v._1._1), right: Data$dEither.$Either("Left", mempty)}; }
+        if (v._1.tag === "Right") { return {left: Data$dEither.$Either("Left", mempty), right: Data$dEither.$Either("Right", v._1._1)}; }
+      }
+      $runtime.fail();
+    }
+  };
+};
+const compactableArray = {
+  compact: xs => {
+    const result = [];
+    const $0 = {value: 0};
+    Data$dArray$dST$dIterator.iterate(Data$dArray$dST$dIterator.$Iterator(
+      v => {
+        if (v >= 0 && v < xs.length) { return Data$dMaybe.$Maybe("Just", xs[v]); }
+        return Data$dMaybe.Nothing;
+      },
+      $0
+    ))(x => {
+      const $1 = (() => {
+        if (x.tag === "Nothing") { return () => 0; }
+        if (x.tag === "Just") { return () => result.push(x._1); }
+        $runtime.fail();
+      })();
+      return () => {$1();};
+    })();
+    return result;
+  },
+  separate: xs => {
+    const ls = [];
+    const rs = [];
+    const $0 = {value: 0};
+    Data$dArray$dST$dIterator.iterate(Data$dArray$dST$dIterator.$Iterator(
+      v => {
+        if (v >= 0 && v < xs.length) { return Data$dMaybe.$Maybe("Just", xs[v]); }
+        return Data$dMaybe.Nothing;
+      },
+      $0
+    ))(x => {
+      const $1 = (() => {
+        if (x.tag === "Left") { return () => ls.push(x._1); }
+        if (x.tag === "Right") { return () => rs.push(x._1); }
+        $runtime.fail();
+      })();
+      return () => {$1();};
+    })();
+    return {left: ls, right: rs};
+  }
+};
+const compactDefault = dictFunctor => dictCompactable => {
+  const $0 = dictFunctor.map(v2 => {
+    if (v2.tag === "Nothing") { return Data$dEither.$Either("Left", undefined); }
+    if (v2.tag === "Just") { return Data$dEither.$Either("Right", v2._1); }
+    $runtime.fail();
+  });
+  return x => dictCompactable.separate($0(x)).right;
+};
+const compact = dict => dict.compact;
+const separateDefault = dictFunctor => dictCompactable => xs => (
+  {
+    left: dictCompactable.compact(dictFunctor.map(x => {
+      if (x.tag === "Left") { return Data$dMaybe.$Maybe("Just", x._1); }
+      if (x.tag === "Right") { return Data$dMaybe.Nothing; }
+      $runtime.fail();
+    })(xs)),
+    right: dictCompactable.compact(dictFunctor.map(Data$dEither.hush)(xs))
+  }
+);
+const bindMaybe = dictBind => dictCompactable => x => {
+  const $0 = dictBind.bind(x);
+  return x$1 => dictCompactable.compact($0(x$1));
+};
+const bindEither = dictBind => dictCompactable => x => {
+  const $0 = dictBind.bind(x);
+  return x$1 => dictCompactable.separate($0(x$1));
+};
+const applyMaybe = dictApply => dictCompactable => p => {
+  const $0 = dictApply.apply(p);
+  return x => dictCompactable.compact($0(x));
+};
+const applyEither = dictApply => dictCompactable => p => {
+  const $0 = dictApply.apply(p);
+  return x => dictCompactable.separate($0(x));
+};
+export {
+  applyEither,
+  applyMaybe,
+  bindEither,
+  bindMaybe,
+  compact,
+  compactDefault,
+  compactableArray,
+  compactableEither,
+  compactableList,
+  compactableMap,
+  compactableMaybe,
+  separate,
+  separateDefault,
+  toUnfoldable
+};

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

@@ -0,0 +1,22 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const Comparison = x => x;
+const semigroupComparison = {
+  append: v => v1 => x => {
+    const $0 = v(x);
+    const $1 = v1(x);
+    return x$1 => {
+      const $2 = $0(x$1);
+      const $3 = $1(x$1);
+      if ($2 === "LT") { return Data$dOrdering.LT; }
+      if ($2 === "GT") { return Data$dOrdering.GT; }
+      if ($2 === "EQ") { return $3; }
+      $runtime.fail();
+    };
+  }
+};
+const newtypeComparison = {Coercible0: () => {}};
+const monoidComparison = {mempty: v => v1 => Data$dOrdering.EQ, Semigroup0: () => semigroupComparison};
+const defaultComparison = dictOrd => dictOrd.compare;
+const contravariantComparison = {cmap: f => v => x => y => v(f(x))(f(y))};
+export {Comparison, contravariantComparison, defaultComparison, monoidComparison, newtypeComparison, semigroupComparison};

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

@@ -0,0 +1,56 @@
+const Const = x => x;
+const showConst = dictShow => ({show: v => "(Const " + dictShow.show(v) + ")"});
+const semiringConst = dictSemiring => dictSemiring;
+const semigroupoidConst = {compose: v => v1 => v1};
+const semigroupConst = dictSemigroup => dictSemigroup;
+const ringConst = dictRing => dictRing;
+const ordConst = dictOrd => dictOrd;
+const newtypeConst = {Coercible0: () => {}};
+const monoidConst = dictMonoid => dictMonoid;
+const heytingAlgebraConst = dictHeytingAlgebra => dictHeytingAlgebra;
+const functorConst = {map: f => m => m};
+const invariantConst = {imap: f => v => m => m};
+const euclideanRingConst = dictEuclideanRing => dictEuclideanRing;
+const eqConst = dictEq => dictEq;
+const eq1Const = dictEq => {
+  const eq = dictEq.eq;
+  return {eq1: dictEq1 => eq};
+};
+const ord1Const = dictOrd => {
+  const compare = dictOrd.compare;
+  const eq = dictOrd.Eq0().eq;
+  return {compare1: dictOrd1 => compare, Eq10: () => ({eq1: dictEq1 => eq})};
+};
+const commutativeRingConst = dictCommutativeRing => dictCommutativeRing;
+const boundedConst = dictBounded => dictBounded;
+const booleanAlgebraConst = dictBooleanAlgebra => dictBooleanAlgebra;
+const applyConst = dictSemigroup => ({apply: v => v1 => dictSemigroup.append(v)(v1), Functor0: () => functorConst});
+const applicativeConst = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const $0 = dictMonoid.Semigroup0();
+  const applyConst1 = {apply: v => v1 => $0.append(v)(v1), Functor0: () => functorConst};
+  return {pure: v => mempty, Apply0: () => applyConst1};
+};
+export {
+  Const,
+  applicativeConst,
+  applyConst,
+  booleanAlgebraConst,
+  boundedConst,
+  commutativeRingConst,
+  eq1Const,
+  eqConst,
+  euclideanRingConst,
+  functorConst,
+  heytingAlgebraConst,
+  invariantConst,
+  monoidConst,
+  newtypeConst,
+  ord1Const,
+  ordConst,
+  ringConst,
+  semigroupConst,
+  semigroupoidConst,
+  semiringConst,
+  showConst
+};

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

@@ -0,0 +1,212 @@
+import * as Data$dSemigroup$dFoldable from "../Data.Semigroup.Foldable/index.js";
+const $CoyonedaF = (_1, _2) => ({tag: "CoyonedaF", _1, _2});
+const CoyonedaF = value0 => value1 => $CoyonedaF(value0, value1);
+const Coyoneda = x => x;
+const unCoyoneda = f => v => f(v._1)(v._2);
+const lowerCoyoneda = dictFunctor => v => dictFunctor.map(v._1)(v._2);
+const foldableCoyoneda = dictFoldable => (
+  {
+    foldr: f => z => v => dictFoldable.foldr(x => f(v._1(x)))(z)(v._2),
+    foldl: f => z => v => dictFoldable.foldl(x => {
+      const $0 = f(x);
+      return x$1 => $0(v._1(x$1));
+    })(z)(v._2),
+    foldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return f => v => foldMap1(x => f(v._1(x)))(v._2);
+    }
+  }
+);
+const foldable1Coyoneda = dictFoldable1 => {
+  const foldableCoyoneda1 = foldableCoyoneda(dictFoldable1.Foldable0());
+  return {
+    foldMap1: dictSemigroup => {
+      const foldMap11 = dictFoldable1.foldMap1(dictSemigroup);
+      return f => v => foldMap11(x => f(v._1(x)))(v._2);
+    },
+    foldr1: Data$dSemigroup$dFoldable.foldr1Default(foldable1Coyoneda(dictFoldable1)),
+    foldl1: Data$dSemigroup$dFoldable.foldl1Default(foldable1Coyoneda(dictFoldable1)),
+    Foldable0: () => foldableCoyoneda1
+  };
+};
+const eqCoyoneda = dictFunctor => dictEq1 => dictEq => {
+  const eq11 = dictEq1.eq1(dictEq);
+  return {eq: x => y => eq11(dictFunctor.map(x._1)(x._2))(dictFunctor.map(y._1)(y._2))};
+};
+const ordCoyoneda = dictFunctor => dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd => {
+    const compare11 = dictOrd1.compare1(dictOrd);
+    const eq11 = $0.eq1(dictOrd.Eq0());
+    const eqCoyoneda3 = {eq: x => y => eq11(dictFunctor.map(x._1)(x._2))(dictFunctor.map(y._1)(y._2))};
+    return {compare: x => y => compare11(dictFunctor.map(x._1)(x._2))(dictFunctor.map(y._1)(y._2)), Eq0: () => eqCoyoneda3};
+  };
+};
+const eq1Coyoneda = dictFunctor => dictEq1 => (
+  {
+    eq1: dictEq => {
+      const eq11 = dictEq1.eq1(dictEq);
+      return x => y => eq11(dictFunctor.map(x._1)(x._2))(dictFunctor.map(y._1)(y._2));
+    }
+  }
+);
+const ord1Coyoneda = dictFunctor => dictOrd1 => {
+  const ordCoyoneda2 = ordCoyoneda(dictFunctor)(dictOrd1);
+  const $0 = dictOrd1.Eq10();
+  const eq1Coyoneda2 = {
+    eq1: dictEq => {
+      const eq11 = $0.eq1(dictEq);
+      return x => y => eq11(dictFunctor.map(x._1)(x._2))(dictFunctor.map(y._1)(y._2));
+    }
+  };
+  return {compare1: dictOrd => ordCoyoneda2(dictOrd).compare, Eq10: () => eq1Coyoneda2};
+};
+const coyoneda = k => fi => $CoyonedaF(k, fi);
+const functorCoyoneda = {map: f => v => $CoyonedaF(x => f(v._1(x)), v._2)};
+const invatiantCoyoneda = {imap: f => v => v$1 => $CoyonedaF(x => f(v$1._1(x)), v$1._2)};
+const hoistCoyoneda = nat => v => $CoyonedaF(v._1, nat(v._2));
+const liftCoyoneda = fi => $CoyonedaF(x => x, fi);
+const distributiveCoyoneda = dictDistributive => {
+  const $0 = dictDistributive.Functor0();
+  return {
+    collect: dictFunctor => {
+      const collect1 = dictDistributive.collect(dictFunctor);
+      return f => {
+        const $1 = collect1(x => {
+          const $1 = f(x);
+          return $0.map($1._1)($1._2);
+        });
+        return x => $CoyonedaF(x$1 => x$1, $1(x));
+      };
+    },
+    distribute: dictFunctor => {
+      const $1 = dictDistributive.collect(dictFunctor)(v => $0.map(v._1)(v._2));
+      return x => $CoyonedaF(x$1 => x$1, $1(x));
+    },
+    Functor0: () => functorCoyoneda
+  };
+};
+const extendCoyoneda = dictExtend => (
+  {
+    extend: f => v => {
+      const $0 = v._1;
+      return $CoyonedaF(x => x, dictExtend.extend(x => f($CoyonedaF($0, x)))(v._2));
+    },
+    Functor0: () => functorCoyoneda
+  }
+);
+const monadTransCoyoneda = {lift: dictMonad => liftCoyoneda};
+const traversableCoyoneda = dictTraversable => {
+  const foldableCoyoneda1 = foldableCoyoneda(dictTraversable.Foldable1());
+  return {
+    traverse: dictApplicative => {
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return f => v => dictApplicative.Apply0().Functor0().map(liftCoyoneda)(traverse1(x => f(v._1(x)))(v._2));
+    },
+    sequence: dictApplicative => {
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return v => dictApplicative.Apply0().Functor0().map(liftCoyoneda)(traverse1(v._1)(v._2));
+    },
+    Functor0: () => functorCoyoneda,
+    Foldable1: () => foldableCoyoneda1
+  };
+};
+const traversable1Coyoneda = dictTraversable1 => {
+  const Traversable1 = dictTraversable1.Traversable1();
+  const foldable1Coyoneda1 = foldable1Coyoneda(dictTraversable1.Foldable10());
+  const traversableCoyoneda1 = traversableCoyoneda(Traversable1);
+  return {
+    traverse1: dictApply => {
+      const traverse11 = dictTraversable1.traverse1(dictApply);
+      return f => v => dictApply.Functor0().map(liftCoyoneda)(traverse11(x => f(v._1(x)))(v._2));
+    },
+    sequence1: dictApply => {
+      const sequence11 = dictTraversable1.sequence1(dictApply);
+      return v => dictApply.Functor0().map(liftCoyoneda)(sequence11(Traversable1.Functor0().map(v._1)(v._2)));
+    },
+    Foldable10: () => foldable1Coyoneda1,
+    Traversable1: () => traversableCoyoneda1
+  };
+};
+const comonadCoyoneda = dictComonad => {
+  const extendCoyoneda1 = extendCoyoneda(dictComonad.Extend0());
+  return {extract: v => v._1(dictComonad.extract(v._2)), Extend0: () => extendCoyoneda1};
+};
+const applyCoyoneda = dictApply => {
+  const $0 = dictApply.Functor0();
+  return {apply: f => g => $CoyonedaF(x => x, dictApply.apply($0.map(f._1)(f._2))($0.map(g._1)(g._2))), Functor0: () => functorCoyoneda};
+};
+const bindCoyoneda = dictBind => {
+  const Apply0 = dictBind.Apply0();
+  const $0 = Apply0.Functor0();
+  const applyCoyoneda1 = applyCoyoneda(Apply0);
+  return {
+    bind: v => f => $CoyonedaF(
+      x => x,
+      dictBind.bind(v._2)(x => {
+        const $1 = f(v._1(x));
+        return $0.map($1._1)($1._2);
+      })
+    ),
+    Apply0: () => applyCoyoneda1
+  };
+};
+const applicativeCoyoneda = dictApplicative => {
+  const applyCoyoneda1 = applyCoyoneda(dictApplicative.Apply0());
+  return {pure: x => $CoyonedaF(x$1 => x$1, dictApplicative.pure(x)), Apply0: () => applyCoyoneda1};
+};
+const monadCoyoneda = dictMonad => {
+  const applicativeCoyoneda1 = applicativeCoyoneda(dictMonad.Applicative0());
+  const bindCoyoneda1 = bindCoyoneda(dictMonad.Bind1());
+  return {Applicative0: () => applicativeCoyoneda1, Bind1: () => bindCoyoneda1};
+};
+const altCoyoneda = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  return {alt: x => y => $CoyonedaF(x$1 => x$1, dictAlt.alt($0.map(x._1)(x._2))($0.map(y._1)(y._2))), Functor0: () => functorCoyoneda};
+};
+const plusCoyoneda = dictPlus => {
+  const altCoyoneda1 = altCoyoneda(dictPlus.Alt0());
+  return {empty: $CoyonedaF(x => x, dictPlus.empty), Alt0: () => altCoyoneda1};
+};
+const alternativeCoyoneda = dictAlternative => {
+  const applicativeCoyoneda1 = applicativeCoyoneda(dictAlternative.Applicative0());
+  const plusCoyoneda1 = plusCoyoneda(dictAlternative.Plus1());
+  return {Applicative0: () => applicativeCoyoneda1, Plus1: () => plusCoyoneda1};
+};
+const monadPlusCoyoneda = dictMonadPlus => {
+  const monadCoyoneda1 = monadCoyoneda(dictMonadPlus.Monad0());
+  const alternativeCoyoneda1 = alternativeCoyoneda(dictMonadPlus.Alternative1());
+  return {Monad0: () => monadCoyoneda1, Alternative1: () => alternativeCoyoneda1};
+};
+export {
+  $CoyonedaF,
+  Coyoneda,
+  CoyonedaF,
+  altCoyoneda,
+  alternativeCoyoneda,
+  applicativeCoyoneda,
+  applyCoyoneda,
+  bindCoyoneda,
+  comonadCoyoneda,
+  coyoneda,
+  distributiveCoyoneda,
+  eq1Coyoneda,
+  eqCoyoneda,
+  extendCoyoneda,
+  foldable1Coyoneda,
+  foldableCoyoneda,
+  functorCoyoneda,
+  hoistCoyoneda,
+  invatiantCoyoneda,
+  liftCoyoneda,
+  lowerCoyoneda,
+  monadCoyoneda,
+  monadPlusCoyoneda,
+  monadTransCoyoneda,
+  ord1Coyoneda,
+  ordCoyoneda,
+  plusCoyoneda,
+  traversable1Coyoneda,
+  traversableCoyoneda,
+  unCoyoneda
+};

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

@@ -0,0 +1,22 @@
+var createDate = function (y, m, d) {
+  var date = new Date(Date.UTC(y, m, d));
+  if (y >= 0 && y < 100) {
+    date.setUTCFullYear(y);
+  }
+  return date;
+};
+
+export function canonicalDateImpl(ctor, y, m, d) {
+  var date = createDate(y, m - 1, d);
+  return ctor(date.getUTCFullYear())(date.getUTCMonth() + 1)(date.getUTCDate());
+}
+
+export function calcWeekday(y, m, d) {
+  return createDate(y, m - 1, d).getUTCDay();
+}
+
+export function calcDiff(y1, m1, d1, y2, m2, d2) {
+  var dt1 = createDate(y1, m1 - 1, d1);
+  var dt2 = createDate(y2, m2 - 1, d2);
+  return dt1.getTime() - dt2.getTime();
+}