@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Benchmark/index.js

@@ -0,0 +1,63 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dReader$dTrans from "../Control.Monad.Reader.Trans/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTraversable from "../Data.Traversable/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Effect$dAff$dClass from "../Effect.Aff.Class/index.js";
+import * as Effect$dConsole from "../Effect.Console/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Module$dNode from "../Module.Node/index.js";
+import * as Node$dEncoding from "../Node.Encoding/index.js";
+import * as Node$dFS$dSync from "../Node.FS.Sync/index.js";
+import * as Test$dBenchmark$dUtil from "../Test.Benchmark.Util/index.js";
+import * as Test$dSpecs$dBwd from "../Test.Specs.Bwd/index.js";
+import * as Test$dSpecs$dDesugar from "../Test.Specs.Desugar/index.js";
+import * as Test$dSpecs$dGraphics from "../Test.Specs.Graphics/index.js";
+import * as Test$dSpecs$dMisc from "../Test.Specs.Misc/index.js";
+import * as Test$dUtil from "../Test.Util/index.js";
+import * as Test$dUtil$dSuite from "../Test.Util.Suite/index.js";
+import * as Util from "../Util/index.js";
+const handleBench = v => {
+  if (v.tag === "Left") { return Effect$dException.throwException(Effect$dException.error(Effect$dException.showErrorImpl(v._1)))(); }
+  if (v.tag === "Right") {
+    const $0 = Node$dFS$dSync.writeTextFile(Node$dEncoding.ASCII)("benchmark/benchmarks_artifact.csv")(Test$dBenchmark$dUtil.showBenchAcc.show(v._1));
+    return () => {
+      $0();
+      return Effect$dConsole.log("Benchmarking data written to benchmark/benchmarks_artifact.csv")();
+    };
+  }
+  $runtime.fail();
+};
+const benchmarks = dictMonadAff => {
+  const bwdSuite = Test$dUtil$dSuite.bwdSuite(dictMonadAff);
+  return dictMonadError => {
+    const bwdSuite1 = bwdSuite(dictMonadError);
+    return dictMonadReader => {
+      const suite2 = Test$dUtil$dSuite.suite(dictMonadAff)(dictMonadError)(dictMonadReader);
+      const bwdSuite2 = bwdSuite1(dictMonadReader);
+      return dictLoadFile => {
+        const suite3 = suite2(dictLoadFile);
+        return [
+          suite3(Test$dSpecs$dDesugar.desugar_cases),
+          suite3(Test$dSpecs$dMisc.misc_cases),
+          bwdSuite2(dictLoadFile)(Test$dSpecs$dBwd.bwd_cases),
+          suite3(Test$dSpecs$dGraphics.graphics_cases)
+        ];
+      };
+    };
+  };
+};
+const main = /* #__PURE__ */ (() => {
+  const $0 = Effect$dAff.runAff(handleBench)(Effect$dAff._bind(Data$dTraversable.traversableArray.traverse(Effect$dAff.applicativeAff)(Data$dTraversable.identity)(Data$dFunctor.arrayMap(x => {
+    const $0 = x._1;
+    const $1 = x._2({fluidSrcPaths: Test$dUtil.fluidSrcPaths});
+    return Effect$dAff._bind(Effect$dAff._liftEffect(Effect$dConsole.log("Benchmarking: " + $0)))(() => Effect$dAff._map(v1 => Data$dTuple.$Tuple($0, v1))($1));
+  })(Data$dArray.concat(Data$dFunctor.arrayMap(f => f(Data$dTuple.$Tuple(10, true)))(benchmarks(Effect$dAff$dClass.monadAffReader(Effect$dAff$dClass.monadAffAff))(Control$dMonad$dReader$dTrans.monadErrorReaderT(Effect$dAff.monadErrorAff))(Control$dMonad$dReader$dTrans.monadReaderReaderT(Effect$dAff.monadAff))(Module$dNode.loadFileNodeT(Effect$dAff.monadAff)))))))(outs => Effect$dAff._pure(Util.definitely("More than one benchmark")(outs.length > 0
+    ? Data$dMaybe.$Maybe("Just", outs)
+    : Data$dMaybe.Nothing))));
+  return () => {$0();};
+})();
+export {benchmarks, handleBench, main};

package/output-es/Bind/index.js

@@ -0,0 +1,24 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Util from "../Util/index.js";
+import * as Util$dSet from "../Util.Set/index.js";
+const union = /* #__PURE__ */ (() => Util$dSet.setSet(Data$dOrd.ordString).union)();
+const varAnon = "_";
+const val = Data$dTuple.snd;
+const showBind = dictShow => x => x$1 => Data$dTuple.$Tuple(x, dictShow.show(x$1));
+const mustGeq = x => y => Util.definitely("greater")((() => {
+  const $0 = x === y;
+  if (!$0) { return Data$dMaybe.Nothing; }
+  if ($0) { return Data$dMaybe.$Maybe("Just", x); }
+  $runtime.fail();
+})());
+const keys = v => {
+  if (v.tag === "Nil") { return Data$dMap$dInternal.Leaf; }
+  if (v.tag === "Cons") { return union(Data$dMap$dInternal.$$$Map("Node", 1, 1, v._1._1, undefined, Data$dMap$dInternal.Leaf, Data$dMap$dInternal.Leaf))(keys(v._2)); }
+  $runtime.fail();
+};
+const key = Data$dTuple.fst;
+export {key, keys, mustGeq, showBind, union, val, varAnon};

package/output-es/Control.Alt/index.js

@@ -0,0 +1,5 @@
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+const altArray = {alt: Data$dSemigroup.concatArray, Functor0: () => Data$dFunctor.functorArray};
+const alt = dict => dict.alt;
+export {alt, altArray};

package/output-es/Control.Alternative/index.js

@@ -0,0 +1,11 @@
+import * as Control$dApplicative from "../Control.Applicative/index.js";
+import * as Control$dPlus from "../Control.Plus/index.js";
+const guard = dictAlternative => {
+  const empty = dictAlternative.Plus1().empty;
+  return v => {
+    if (v) { return dictAlternative.Applicative0().pure(); }
+    return empty;
+  };
+};
+const alternativeArray = {Applicative0: () => Control$dApplicative.applicativeArray, Plus1: () => Control$dPlus.plusArray};
+export {alternativeArray, guard};

package/output-es/Control.Applicative/index.js

@@ -0,0 +1,18 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dApply from "../Control.Apply/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+const pure = dict => dict.pure;
+const unless = dictApplicative => v => v1 => {
+  if (!v) { return v1; }
+  if (v) { return dictApplicative.pure(); }
+  $runtime.fail();
+};
+const when = dictApplicative => v => v1 => {
+  if (v) { return v1; }
+  return dictApplicative.pure();
+};
+const liftA1 = dictApplicative => f => a => dictApplicative.Apply0().apply(dictApplicative.pure(f))(a);
+const applicativeProxy = {pure: v => Type$dProxy.Proxy, Apply0: () => Control$dApply.applyProxy};
+const applicativeFn = {pure: x => v => x, Apply0: () => Control$dApply.applyFn};
+const applicativeArray = {pure: x => [x], Apply0: () => Control$dApply.applyArray};
+export {applicativeArray, applicativeFn, applicativeProxy, liftA1, pure, unless, when};

package/output-es/Control.Apply/foreign.js

@@ -0,0 +1,15 @@
+export const arrayApply = function (fs) {
+  return function (xs) {
+    var l = fs.length;
+    var k = xs.length;
+    var result = new Array(l*k);
+    var n = 0;
+    for (var i = 0; i < l; i++) {
+      var f = fs[i];
+      for (var j = 0; j < k; j++) {
+        result[n++] = f(xs[j]);
+      }
+    }
+    return result;
+  };
+};

package/output-es/Control.Apply/index.js

@@ -0,0 +1,17 @@
+import * as Data$dFunction from "../Data.Function/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {arrayApply} from "./foreign.js";
+const identity = x => x;
+const applyProxy = {apply: v => v1 => Type$dProxy.Proxy, Functor0: () => Data$dFunctor.functorProxy};
+const applyFn = {apply: f => g => x => f(x)(g(x)), Functor0: () => Data$dFunctor.functorFn};
+const applyArray = {apply: arrayApply, Functor0: () => Data$dFunctor.functorArray};
+const apply = dict => dict.apply;
+const applyFirst = dictApply => a => b => dictApply.apply(dictApply.Functor0().map(Data$dFunction.const)(a))(b);
+const applySecond = dictApply => a => b => dictApply.apply(dictApply.Functor0().map(v => identity)(a))(b);
+const lift2 = dictApply => f => a => b => dictApply.apply(dictApply.Functor0().map(f)(a))(b);
+const lift3 = dictApply => f => a => b => c => dictApply.apply(dictApply.apply(dictApply.Functor0().map(f)(a))(b))(c);
+const lift4 = dictApply => f => a => b => c => d => dictApply.apply(dictApply.apply(dictApply.apply(dictApply.Functor0().map(f)(a))(b))(c))(d);
+const lift5 = dictApply => f => a => b => c => d => e => dictApply.apply(dictApply.apply(dictApply.apply(dictApply.apply(dictApply.Functor0().map(f)(a))(b))(c))(d))(e);
+export {apply, applyArray, applyFirst, applyFn, applyProxy, applySecond, identity, lift2, lift3, lift4, lift5};
+export * from "./foreign.js";

package/output-es/Control.Biapplicative/index.js

@@ -0,0 +1,5 @@
+import * as Control$dBiapply from "../Control.Biapply/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const bipure = dict => dict.bipure;
+const biapplicativeTuple = {bipure: Data$dTuple.Tuple, Biapply0: () => Control$dBiapply.biapplyTuple};
+export {biapplicativeTuple, bipure};

package/output-es/Control.Biapply/index.js

@@ -0,0 +1,11 @@
+import * as Data$dBifunctor from "../Data.Bifunctor/index.js";
+import * as Data$dFunction from "../Data.Function/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const biapplyTuple = {biapply: v => v1 => Data$dTuple.$Tuple(v._1(v1._1), v._2(v1._2)), Bifunctor0: () => Data$dBifunctor.bifunctorTuple};
+const biapply = dict => dict.biapply;
+const biapplyFirst = dictBiapply => a => b => dictBiapply.biapply(dictBiapply.Bifunctor0().bimap(v => identity)(v => identity)(a))(b);
+const biapplySecond = dictBiapply => a => b => dictBiapply.biapply(dictBiapply.Bifunctor0().bimap(Data$dFunction.const)(Data$dFunction.const)(a))(b);
+const bilift2 = dictBiapply => f => g => a => b => dictBiapply.biapply(dictBiapply.Bifunctor0().bimap(f)(g)(a))(b);
+const bilift3 = dictBiapply => f => g => a => b => c => dictBiapply.biapply(dictBiapply.biapply(dictBiapply.Bifunctor0().bimap(f)(g)(a))(b))(c);
+export {biapply, biapplyFirst, biapplySecond, biapplyTuple, bilift2, bilift3, identity};

package/output-es/Control.Bind/foreign.js

@@ -0,0 +1,9 @@
+export const arrayBind = function (arr) {
+  return function (f) {
+    var result = [];
+    for (var i = 0, l = arr.length; i < l; i++) {
+      Array.prototype.push.apply(result, f(arr[i]));
+    }
+    return result;
+  };
+};

package/output-es/Control.Bind/index.js

@@ -0,0 +1,21 @@
+import * as Control$dApply from "../Control.Apply/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {arrayBind} from "./foreign.js";
+const identity = x => x;
+const discard = dict => dict.discard;
+const bindProxy = {bind: v => v1 => Type$dProxy.Proxy, Apply0: () => Control$dApply.applyProxy};
+const bindFn = {bind: m => f => x => f(m(x))(x), Apply0: () => Control$dApply.applyFn};
+const bindArray = {bind: arrayBind, Apply0: () => Control$dApply.applyArray};
+const bind = dict => dict.bind;
+const bindFlipped = dictBind => b => a => dictBind.bind(a)(b);
+const composeKleisliFlipped = dictBind => f => g => a => dictBind.bind(g(a))(f);
+const composeKleisli = dictBind => f => g => a => dictBind.bind(f(a))(g);
+const discardProxy = {discard: dictBind => dictBind.bind};
+const discardUnit = {discard: dictBind => dictBind.bind};
+const ifM = dictBind => cond => t => f => dictBind.bind(cond)(cond$p => {
+  if (cond$p) { return t; }
+  return f;
+});
+const join = dictBind => m => dictBind.bind(m)(identity);
+export {bind, bindArray, bindFlipped, bindFn, bindProxy, composeKleisli, composeKleisliFlipped, discard, discardProxy, discardUnit, identity, ifM, join};
+export * from "./foreign.js";

package/output-es/Control.Category/index.js

@@ -0,0 +1,4 @@
+import * as Control$dSemigroupoid from "../Control.Semigroupoid/index.js";
+const identity = dict => dict.identity;
+const categoryFn = {identity: x => x, Semigroupoid0: () => Control$dSemigroupoid.semigroupoidFn};
+export {categoryFn, identity};

package/output-es/Control.Comonad/index.js

@@ -0,0 +1,2 @@
+const extract = dict => dict.extract;
+export {extract};

package/output-es/Control.Comonad.Cofree/index.js

@@ -0,0 +1,255 @@
+// | The _cofree comonad_ for a `Functor`.
+import * as Control$dMonad$dFree from "../Control.Monad.Free/index.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dLazy from "../Data.Lazy/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const state = /* #__PURE__ */ (() => Control$dMonad$dState$dTrans.monadStateStateT(Data$dIdentity.monadIdentity).state)();
+const monadRecStateT = /* #__PURE__ */ Control$dMonad$dState$dTrans.monadRecStateT(Control$dMonad$dRec$dClass.monadRecIdentity);
+const tail = v => Data$dLazy.force(v)._2;
+const mkCofree = a => t => Data$dLazy.defer(v => Data$dTuple.$Tuple(a, t));
+const lazyCofree = {defer: k => Data$dLazy.defer(v => Data$dLazy.force(k()))};
+const hoistCofree = dictFunctor => nat => v => {
+  const $0 = dictFunctor.map(hoistCofree(dictFunctor)(nat));
+  return Data$dLazy.defer(v$1 => {
+    const $1 = Data$dLazy.force(v);
+    return Data$dTuple.$Tuple($1._1, nat($0($1._2)));
+  });
+};
+const head = v => Data$dLazy.force(v)._1;
+const functorCofree = dictFunctor => (
+  {
+    map: f => {
+      const loop = v => Data$dLazy.defer(v$1 => {
+        const $0 = Data$dLazy.force(v);
+        return Data$dTuple.$Tuple(f($0._1), dictFunctor.map(loop)($0._2));
+      });
+      return loop;
+    }
+  }
+);
+const functorWithIndexCofree = dictFunctor => {
+  const functorCofree1 = functorCofree(dictFunctor);
+  return {
+    mapWithIndex: f => {
+      const loop = n => v => Data$dLazy.defer(v$1 => {
+        const $0 = Data$dLazy.force(v);
+        return Data$dTuple.$Tuple(f(n)($0._1), dictFunctor.map(loop(n + 1 | 0))($0._2));
+      });
+      return loop(0);
+    },
+    Functor0: () => functorCofree1
+  };
+};
+const foldableCofree = dictFoldable => (
+  {
+    foldr: f => {
+      const go = fa => b => f(Data$dLazy.force(fa)._1)(dictFoldable.foldr(go)(b)(Data$dLazy.force(fa)._2));
+      return b => a => go(a)(b);
+    },
+    foldl: f => {
+      const go = b => fa => dictFoldable.foldl(go)(f(b)(Data$dLazy.force(fa)._1))(Data$dLazy.force(fa)._2);
+      return go;
+    },
+    foldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return f => {
+        const go = fa => dictMonoid.Semigroup0().append(f(Data$dLazy.force(fa)._1))(foldMap1(go)(Data$dLazy.force(fa)._2));
+        return go;
+      };
+    }
+  }
+);
+const foldableWithIndexCofree = dictFoldable => {
+  const foldableCofree1 = foldableCofree(dictFoldable);
+  return {
+    foldrWithIndex: f => {
+      const go = ix => b => fa => f(ix)(Data$dLazy.force(fa)._1)(dictFoldable.foldr((() => {
+        const $0 = go(ix + 1 | 0);
+        return b$1 => a => $0(a)(b$1);
+      })())(b)(Data$dLazy.force(fa)._2));
+      return go(0);
+    },
+    foldlWithIndex: f => {
+      const go = ix => b => fa => dictFoldable.foldl(go(ix + 1 | 0))(f(ix)(b)(Data$dLazy.force(fa)._1))(Data$dLazy.force(fa)._2);
+      return go(0);
+    },
+    foldMapWithIndex: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return f => {
+        const go = ix => fa => dictMonoid.Semigroup0().append(f(ix)(Data$dLazy.force(fa)._1))(foldMap1(go(ix + 1 | 0))(Data$dLazy.force(fa)._2));
+        return go(0);
+      };
+    },
+    Foldable0: () => foldableCofree1
+  };
+};
+const traversableCofree = dictTraversable => {
+  const functorCofree1 = functorCofree(dictTraversable.Functor0());
+  const foldableCofree1 = foldableCofree(dictTraversable.Foldable1());
+  return {
+    sequence: dictApplicative => traversableCofree(dictTraversable).traverse(dictApplicative)(identity),
+    traverse: dictApplicative => {
+      const Apply0 = dictApplicative.Apply0();
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return f => {
+        const loop = ta => Apply0.apply(Apply0.Functor0().map(mkCofree)(f(Data$dLazy.force(ta)._1)))(traverse1(loop)(Data$dLazy.force(ta)._2));
+        return loop;
+      };
+    },
+    Functor0: () => functorCofree1,
+    Foldable1: () => foldableCofree1
+  };
+};
+const traversableWithIndexCofree = dictTraversable => {
+  const functorWithIndexCofree1 = functorWithIndexCofree(dictTraversable.Functor0());
+  const foldableWithIndexCofree1 = foldableWithIndexCofree(dictTraversable.Foldable1());
+  const traversableCofree1 = traversableCofree(dictTraversable);
+  return {
+    traverseWithIndex: dictApplicative => {
+      const Apply0 = dictApplicative.Apply0();
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return f => {
+        const loop = ix => ta => Apply0.apply(Apply0.Functor0().map(mkCofree)(f(ix)(Data$dLazy.force(ta)._1)))(traverse1(loop(ix + 1 | 0))(Data$dLazy.force(ta)._2));
+        return loop(0);
+      };
+    },
+    FunctorWithIndex0: () => functorWithIndexCofree1,
+    FoldableWithIndex1: () => foldableWithIndexCofree1,
+    Traversable2: () => traversableCofree1
+  };
+};
+const extendCofree = dictFunctor => {
+  const functorCofree1 = functorCofree(dictFunctor);
+  return {
+    extend: f => {
+      const loop = v => Data$dLazy.defer(v$1 => Data$dTuple.$Tuple(f(v), dictFunctor.map(loop)(Data$dLazy.force(v)._2)));
+      return loop;
+    },
+    Functor0: () => functorCofree1
+  };
+};
+const eqCofree = dictEq1 => dictEq => (
+  {eq: x => y => dictEq.eq(Data$dLazy.force(x)._1)(Data$dLazy.force(y)._1) && dictEq1.eq1(eqCofree(dictEq1)(dictEq))(Data$dLazy.force(x)._2)(Data$dLazy.force(y)._2)}
+);
+const ordCofree = dictOrd1 => {
+  const eqCofree1 = eqCofree(dictOrd1.Eq10());
+  return dictOrd => {
+    const eqCofree2 = eqCofree1(dictOrd.Eq0());
+    return {
+      compare: x => y => {
+        const v = dictOrd.compare(Data$dLazy.force(x)._1)(Data$dLazy.force(y)._1);
+        if (v === "EQ") { return dictOrd1.compare1(ordCofree(dictOrd1)(dictOrd))(Data$dLazy.force(x)._2)(Data$dLazy.force(y)._2); }
+        return v;
+      },
+      Eq0: () => eqCofree2
+    };
+  };
+};
+const eq1Cofree = dictEq1 => ({eq1: dictEq => eqCofree(dictEq1)(dictEq).eq});
+const ord1Cofree = dictOrd1 => {
+  const ordCofree1 = ordCofree(dictOrd1);
+  const $0 = dictOrd1.Eq10();
+  const eq1Cofree1 = {eq1: dictEq => eqCofree($0)(dictEq).eq};
+  return {compare1: dictOrd => ordCofree1(dictOrd).compare, Eq10: () => eq1Cofree1};
+};
+const deferCofree = x => Data$dLazy.defer(x);
+const semigroupCofree = dictApply => dictSemigroup => (
+  {
+    append: x => y => Data$dLazy.defer(v => Data$dTuple.$Tuple(
+      dictSemigroup.append(Data$dLazy.force(x)._1)(Data$dLazy.force(y)._1),
+      dictApply.apply(dictApply.Functor0().map(semigroupCofree(dictApply)(dictSemigroup).append)(Data$dLazy.force(x)._2))(Data$dLazy.force(y)._2)
+    ))
+  }
+);
+const monoidCofree = dictApplicative => {
+  const semigroupCofree1 = semigroupCofree(dictApplicative.Apply0());
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const semigroupCofree2 = semigroupCofree1(dictMonoid.Semigroup0());
+    return {mempty: Data$dLazy.defer(v => Data$dTuple.$Tuple(mempty, dictApplicative.pure(monoidCofree(dictApplicative)(dictMonoid).mempty))), Semigroup0: () => semigroupCofree2};
+  };
+};
+const comonadCofree = dictFunctor => {
+  const extendCofree1 = extendCofree(dictFunctor);
+  return {extract: head, Extend0: () => extendCofree1};
+};
+const explore = dictFunctor => {
+  const runFreeM = Control$dMonad$dFree.runFreeM(dictFunctor)(monadRecStateT);
+  return dictFunctor1 => pair => m => w => {
+    const v = runFreeM(ff => state(cof => pair(dictFunctor.map(Data$dTuple.Tuple)(ff))(Data$dLazy.force(cof)._2)))(m)(w);
+    return v._1(Data$dLazy.force(v._2)._1);
+  };
+};
+const exploreM = dictFunctor => dictFunctor1 => dictMonadRec => {
+  const runFreeM1 = Control$dMonad$dFree.runFreeM(dictFunctor)(Control$dMonad$dState$dTrans.monadRecStateT(dictMonadRec));
+  return pair => m => w => dictMonadRec.Monad0().Bind1().Apply0().Functor0().map(v => v._1(Data$dLazy.force(v._2)._1))(runFreeM1(ff => cof => pair(dictFunctor.map(Data$dTuple.Tuple)(ff))(Data$dLazy.force(cof)._2))(m)(w));
+};
+const buildCofree = dictFunctor => k => s => Data$dLazy.defer(v => {
+  const $0 = k(s);
+  return Data$dTuple.$Tuple($0._1, dictFunctor.map(buildCofree(dictFunctor)(k))($0._2));
+});
+const monadCofree = dictAlternative => ({Applicative0: () => applicativeCofree(dictAlternative), Bind1: () => bindCofree(dictAlternative)});
+const bindCofree = dictAlternative => {
+  const Alt0 = dictAlternative.Plus1().Alt0();
+  return {
+    bind: fa => f => {
+      const loop = fa$p => {
+        const fh = f(Data$dLazy.force(fa$p)._1);
+        const $0 = Data$dLazy.force(fh)._1;
+        const $1 = Alt0.alt(Data$dLazy.force(fh)._2)(Alt0.Functor0().map(loop)(Data$dLazy.force(fa$p)._2));
+        return Data$dLazy.defer(v => Data$dTuple.$Tuple($0, $1));
+      };
+      return loop(fa);
+    },
+    Apply0: () => applyCofree(dictAlternative)
+  };
+};
+const applyCofree = dictAlternative => {
+  const functorCofree1 = functorCofree(dictAlternative.Plus1().Alt0().Functor0());
+  return {
+    apply: (() => {
+      const $0 = bindCofree(dictAlternative);
+      return f => a => $0.bind(f)(f$p => $0.bind(a)(a$p => applicativeCofree(dictAlternative).pure(f$p(a$p))));
+    })(),
+    Functor0: () => functorCofree1
+  };
+};
+const applicativeCofree = dictAlternative => {
+  const empty = dictAlternative.Plus1().empty;
+  return {pure: a => Data$dLazy.defer(v => Data$dTuple.$Tuple(a, empty)), Apply0: () => applyCofree(dictAlternative)};
+};
+export {
+  applicativeCofree,
+  applyCofree,
+  bindCofree,
+  buildCofree,
+  comonadCofree,
+  deferCofree,
+  eq1Cofree,
+  eqCofree,
+  explore,
+  exploreM,
+  extendCofree,
+  foldableCofree,
+  foldableWithIndexCofree,
+  functorCofree,
+  functorWithIndexCofree,
+  head,
+  hoistCofree,
+  identity,
+  lazyCofree,
+  mkCofree,
+  monadCofree,
+  monadRecStateT,
+  monoidCofree,
+  ord1Cofree,
+  ordCofree,
+  semigroupCofree,
+  state,
+  tail,
+  traversableCofree,
+  traversableWithIndexCofree
+};

package/output-es/Control.Comonad.Cofree.Class/index.js

@@ -0,0 +1,43 @@
+import * as Control$dComonad$dCofree from "../Control.Comonad.Cofree/index.js";
+import * as Control$dComonad$dEnv$dTrans from "../Control.Comonad.Env.Trans/index.js";
+import * as Control$dComonad$dStore$dTrans from "../Control.Comonad.Store.Trans/index.js";
+import * as Control$dComonad$dTraced$dTrans from "../Control.Comonad.Traced.Trans/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const unwrapCofree = dict => dict.unwrapCofree;
+const comonadCofreeTracedT = dictFunctor => dictComonadCofree => {
+  const Functor0 = dictComonadCofree.Functor0();
+  const comonadTracedT = Control$dComonad$dTraced$dTrans.comonadTracedT(dictComonadCofree.Comonad1());
+  return dictMonoid => {
+    const comonadTracedT1 = comonadTracedT(dictMonoid);
+    return {unwrapCofree: v => Functor0.map(Control$dComonad$dTraced$dTrans.TracedT)(dictComonadCofree.unwrapCofree(v)), Functor0: () => Functor0, Comonad1: () => comonadTracedT1};
+  };
+};
+const comonadCofreeStoreT = dictFunctor => dictComonadCofree => {
+  const Functor0 = dictComonadCofree.Functor0();
+  const comonadStoreT = Control$dComonad$dStore$dTrans.comonadStoreT(dictComonadCofree.Comonad1());
+  return {
+    unwrapCofree: v => {
+      const $0 = v._2;
+      return Functor0.map(x => Data$dTuple.$Tuple(x, $0))(dictComonadCofree.unwrapCofree(v._1));
+    },
+    Functor0: () => Functor0,
+    Comonad1: () => comonadStoreT
+  };
+};
+const comonadCofreeEnvT = dictFunctor => dictComonadCofree => {
+  const Functor0 = dictComonadCofree.Functor0();
+  const comonadEnvT = Control$dComonad$dEnv$dTrans.comonadEnvT(dictComonadCofree.Comonad1());
+  return {
+    unwrapCofree: v => {
+      const $0 = v._1;
+      return Functor0.map(x => Data$dTuple.$Tuple($0, x))(dictComonadCofree.unwrapCofree(v._2));
+    },
+    Functor0: () => Functor0,
+    Comonad1: () => comonadEnvT
+  };
+};
+const comonadCofreeCofree = dictFunctor => {
+  const extendCofree1 = Control$dComonad$dCofree.extendCofree(dictFunctor);
+  return {unwrapCofree: Control$dComonad$dCofree.tail, Functor0: () => dictFunctor, Comonad1: () => ({extract: Control$dComonad$dCofree.head, Extend0: () => extendCofree1})};
+};
+export {comonadCofreeCofree, comonadCofreeEnvT, comonadCofreeStoreT, comonadCofreeTracedT, unwrapCofree};

package/output-es/Control.Comonad.Env/index.js

@@ -0,0 +1,8 @@
+// | This module defines the `Env` comonad.
+import * as Control$dComonad$dEnv$dTrans from "../Control.Comonad.Env.Trans/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const withEnv = Control$dComonad$dEnv$dTrans.withEnvT;
+const runEnv = v => Data$dTuple.$Tuple(v._1, v._2);
+const mapEnv = f => v => Data$dTuple.$Tuple(v._1, f(v._2));
+const env = e => a => Data$dTuple.$Tuple(e, a);
+export {env, mapEnv, runEnv, withEnv};

package/output-es/Control.Comonad.Env.Class/index.js

@@ -0,0 +1,17 @@
+// | This module defines the `ComonadEnv` type class and its instances.
+import * as Control$dComonad$dEnv$dTrans from "../Control.Comonad.Env.Trans/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const local = dict => dict.local;
+const comonadAskTuple = {ask: Data$dTuple.fst, Comonad0: () => Data$dTuple.comonadTuple};
+const comonadEnvTuple = {local: f => v => Data$dTuple.$Tuple(f(v._1), v._2), ComonadAsk0: () => comonadAskTuple};
+const comonadAskEnvT = dictComonad => {
+  const comonadEnvT = Control$dComonad$dEnv$dTrans.comonadEnvT(dictComonad);
+  return {ask: v => v._1, Comonad0: () => comonadEnvT};
+};
+const comonadEnvEnvT = dictComonad => {
+  const comonadEnvT = Control$dComonad$dEnv$dTrans.comonadEnvT(dictComonad);
+  return {local: f => v => Data$dTuple.$Tuple(f(v._1), v._2), ComonadAsk0: () => ({ask: v => v._1, Comonad0: () => comonadEnvT})};
+};
+const ask = dict => dict.ask;
+const asks = dictComonadAsk => f => x => f(dictComonadAsk.ask(x));
+export {ask, asks, comonadAskEnvT, comonadAskTuple, comonadEnvEnvT, comonadEnvTuple, local};