@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Data.Function.Memoize/index.js

@@ -0,0 +1,242 @@
+// | This module defines functions for _memoizing_ functions, i.e. creating functions which
+// | remember their results.
+// |
+// | This module works by turning a function into a lazily-evaluated data structure depending on
+// | its domain type.
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dEnum from "../Data.Enum/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+import * as Data$dLazy from "../Data.Lazy/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Data$dUnfoldable from "../Data.Unfoldable/index.js";
+const $NatTrie = (_1, _2, _3) => ({tag: "NatTrie", _1, _2, _3});
+const toUnfoldable = /* #__PURE__ */ (() => Data$dUnfoldable.unfoldableArray.unfoldr(xs => {
+  if (xs.tag === "Nil") { return Data$dMaybe.Nothing; }
+  if (xs.tag === "Cons") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(xs._1, xs._2)); }
+  $runtime.fail();
+}))();
+const fromFoldable = /* #__PURE__ */ Data$dFoldable.foldrArray(Data$dList$dTypes.Cons)(Data$dList$dTypes.Nil);
+const NatTrie = value0 => value1 => value2 => $NatTrie(value0, value1, value2);
+const tabulateUnit = {
+  tabulate: f => {
+    const r = Data$dLazy.defer(v => f());
+    return v => r;
+  }
+};
+const tabulateNoArguments = {
+  tabulate: f => {
+    const r = Data$dLazy.defer(v => f(Data$dGeneric$dRep.NoArguments));
+    return v => r;
+  }
+};
+const tabulateNat = {
+  tabulate: f => {
+    const walk = v => v1 => {
+      if (v.tag === "Nil") { return v1._1; }
+      if (v.tag === "Cons") {
+        if (!v._1) {
+          const $0 = v1._2;
+          const $1 = walk(v._2);
+          return Data$dLazy.defer(v$1 => Data$dLazy.force($1(Data$dLazy.force($0))));
+        }
+        if (v._1) {
+          const $0 = v1._3;
+          const $1 = walk(v._2);
+          return Data$dLazy.defer(v$1 => Data$dLazy.force($1(Data$dLazy.force($0))));
+        }
+      }
+      $runtime.fail();
+    };
+    const build = n => $NatTrie(Data$dLazy.defer(v => f(n)), Data$dLazy.defer(v => build(n * 2 | 0)), Data$dLazy.defer(v => build((n * 2 | 0) + 1 | 0)));
+    const trie = build(0);
+    const bits$p = bits$p$a0$copy => bits$p$a1$copy => {
+      let bits$p$a0 = bits$p$a0$copy, bits$p$a1 = bits$p$a1$copy, bits$p$c = true, bits$p$r;
+      while (bits$p$c) {
+        const v = bits$p$a0, v1 = bits$p$a1;
+        if (v1 === 0) {
+          bits$p$c = false;
+          bits$p$r = v;
+          continue;
+        }
+        bits$p$a0 = Data$dList$dTypes.$List("Cons", (v1 & 1) !== 0, v);
+        bits$p$a1 = v1 >>> 1;
+      }
+      return bits$p$r;
+    };
+    const bits = bits$p(Data$dList$dTypes.Nil);
+    return n => walk(bits(n))(trie);
+  }
+};
+const tabulateBool = {
+  tabulate: f => {
+    const r2 = Data$dLazy.defer(v => f(false));
+    const r1 = Data$dLazy.defer(v => f(true));
+    return b => {
+      if (b) { return r1; }
+      return r2;
+    };
+  }
+};
+const tabulate = dict => dict.tabulate;
+const tabulateArgument = dictTabulate => ({tabulate: f => dictTabulate.tabulate(x => f(x))});
+const tabulateChar = {
+  tabulate: f => {
+    const $0 = tabulateNat.tabulate(x => f((() => {
+      if (x >= 0 && x <= 65535) { return Data$dEnum.fromCharCode(x); }
+      $runtime.fail();
+    })()));
+    return x => $0(Data$dEnum.toCharCode(x));
+  }
+};
+const tabulateConstructor = dictTabulate => ({tabulate: f => dictTabulate.tabulate(x => f(x))});
+const tabulateEither = dictTabulate => dictTabulate1 => (
+  {
+    tabulate: f => {
+      const r = dictTabulate1.tabulate(x => f(Data$dEither.$Either("Right", x)));
+      const l = dictTabulate.tabulate(x => f(Data$dEither.$Either("Left", x)));
+      return v => {
+        if (v.tag === "Left") { return l(v._1); }
+        if (v.tag === "Right") { return r(v._1); }
+        $runtime.fail();
+      };
+    }
+  }
+);
+const tabulateMaybe = dictTabulate => (
+  {
+    tabulate: f => {
+      const n = Data$dLazy.defer(v => f(Data$dMaybe.Nothing));
+      const j = dictTabulate.tabulate(x => f(Data$dMaybe.$Maybe("Just", x)));
+      return v => {
+        if (v.tag === "Nothing") { return n; }
+        if (v.tag === "Just") { return j(v._1); }
+        $runtime.fail();
+      };
+    }
+  }
+);
+const tabulateProduct = dictTabulate => dictTabulate1 => (
+  {
+    tabulate: f => {
+      const f$p = dictTabulate.tabulate(a => dictTabulate1.tabulate(b => f(Data$dGeneric$dRep.$Product(a, b))));
+      return v => {
+        const $0 = v._2;
+        const $1 = f$p(v._1);
+        return Data$dLazy.defer(v$1 => Data$dLazy.force(Data$dLazy.force($1)($0)));
+      };
+    }
+  }
+);
+const tabulateSum = dictTabulate => dictTabulate1 => (
+  {
+    tabulate: f => {
+      const r = dictTabulate1.tabulate(x => f(Data$dGeneric$dRep.$Sum("Inr", x)));
+      const l = dictTabulate.tabulate(x => f(Data$dGeneric$dRep.$Sum("Inl", x)));
+      return v => {
+        if (v.tag === "Inl") { return l(v._1); }
+        if (v.tag === "Inr") { return r(v._1); }
+        $runtime.fail();
+      };
+    }
+  }
+);
+const tabulateTuple = dictTabulate => dictTabulate1 => (
+  {
+    tabulate: f => {
+      const f$p = dictTabulate.tabulate(a => dictTabulate1.tabulate(b => f(Data$dTuple.$Tuple(a, b))));
+      return v => {
+        const $0 = v._2;
+        const $1 = f$p(v._1);
+        return Data$dLazy.defer(v$1 => Data$dLazy.force(Data$dLazy.force($1)($0)));
+      };
+    }
+  }
+);
+const tabulateList = dictTabulate => (
+  {
+    tabulate: f => {
+      const $0 = tabulateMaybe(tabulateTuple(dictTabulate)(tabulateList(dictTabulate))).tabulate(x => f((() => {
+        if (x.tag === "Nothing") { return Data$dList$dTypes.Nil; }
+        if (x.tag === "Just") { return Data$dList$dTypes.$List("Cons", x._1._1, x._1._2); }
+        $runtime.fail();
+      })()));
+      return x => $0((() => {
+        if (x.tag === "Nil") { return Data$dMaybe.Nothing; }
+        if (x.tag === "Cons") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(x._1, x._2)); }
+        $runtime.fail();
+      })());
+    }
+  }
+);
+const tabulateArray = dictTabulate => (
+  {
+    tabulate: f => {
+      const $0 = tabulateList(dictTabulate).tabulate(x => f(toUnfoldable(x)));
+      return x => $0(fromFoldable(x));
+    }
+  }
+);
+const tabulate2 = /* #__PURE__ */ (() => tabulateArray(tabulateChar).tabulate)();
+const tabulateString = {
+  tabulate: f => {
+    const $0 = tabulate2(x => f(Data$dString$dCodeUnits.fromCharArray(x)));
+    return x => $0(Data$dString$dCodeUnits.toCharArray(x));
+  }
+};
+const memoize = dictTabulate => f => {
+  const $0 = dictTabulate.tabulate(f);
+  return x => Data$dLazy.force($0(x));
+};
+const memoize2 = dictTabulate => dictTabulate1 => {
+  const memoize1 = memoize(tabulateTuple(dictTabulate)(dictTabulate1));
+  return f => {
+    const $0 = memoize1(v => f(v._1)(v._2));
+    return a => b => $0(Data$dTuple.$Tuple(a, b));
+  };
+};
+const memoize3 = dictTabulate => dictTabulate1 => {
+  const tabulateTuple2 = tabulateTuple(tabulateTuple(dictTabulate)(dictTabulate1));
+  return dictTabulate2 => {
+    const memoize1 = memoize(tabulateTuple2(dictTabulate2));
+    return f => {
+      const $0 = memoize1(v => f(v._1._1)(v._1._2)(v._2));
+      return a => b => b$1 => $0(Data$dTuple.$Tuple(Data$dTuple.$Tuple(a, b), b$1));
+    };
+  };
+};
+const genericTabulate = dictGeneric => dictTabulate => f => {
+  const $0 = dictTabulate.tabulate(x => f(dictGeneric.to(x)));
+  return x => $0(dictGeneric.from(x));
+};
+export {
+  $NatTrie,
+  NatTrie,
+  fromFoldable,
+  genericTabulate,
+  memoize,
+  memoize2,
+  memoize3,
+  tabulate,
+  tabulate2,
+  tabulateArgument,
+  tabulateArray,
+  tabulateBool,
+  tabulateChar,
+  tabulateConstructor,
+  tabulateEither,
+  tabulateList,
+  tabulateMaybe,
+  tabulateNat,
+  tabulateNoArguments,
+  tabulateProduct,
+  tabulateString,
+  tabulateSum,
+  tabulateTuple,
+  tabulateUnit,
+  toUnfoldable
+};

package/output-es/Data.Function.Uncurried/foreign.js

@@ -0,0 +1,218 @@
+// module Data.Function.Uncurried
+
+export const mkFn0 = function (fn) {
+  return function () {
+    return fn();
+  };
+};
+
+export const mkFn2 = function (fn) {
+  /* jshint maxparams: 2 */
+  return function (a, b) {
+    return fn(a)(b);
+  };
+};
+
+export const mkFn3 = function (fn) {
+  /* jshint maxparams: 3 */
+  return function (a, b, c) {
+    return fn(a)(b)(c);
+  };
+};
+
+export const mkFn4 = function (fn) {
+  /* jshint maxparams: 4 */
+  return function (a, b, c, d) {
+    return fn(a)(b)(c)(d);
+  };
+};
+
+export const mkFn5 = function (fn) {
+  /* jshint maxparams: 5 */
+  return function (a, b, c, d, e) {
+    return fn(a)(b)(c)(d)(e);
+  };
+};
+
+export const mkFn6 = function (fn) {
+  /* jshint maxparams: 6 */
+  return function (a, b, c, d, e, f) {
+    return fn(a)(b)(c)(d)(e)(f);
+  };
+};
+
+export const mkFn7 = function (fn) {
+  /* jshint maxparams: 7 */
+  return function (a, b, c, d, e, f, g) {
+    return fn(a)(b)(c)(d)(e)(f)(g);
+  };
+};
+
+export const mkFn8 = function (fn) {
+  /* jshint maxparams: 8 */
+  return function (a, b, c, d, e, f, g, h) {
+    return fn(a)(b)(c)(d)(e)(f)(g)(h);
+  };
+};
+
+export const mkFn9 = function (fn) {
+  /* jshint maxparams: 9 */
+  return function (a, b, c, d, e, f, g, h, i) {
+    return fn(a)(b)(c)(d)(e)(f)(g)(h)(i);
+  };
+};
+
+export const mkFn10 = function (fn) {
+  /* jshint maxparams: 10 */
+  return function (a, b, c, d, e, f, g, h, i, j) {
+    return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j);
+  };
+};
+
+export const runFn0 = function (fn) {
+  return fn();
+};
+
+export const runFn2 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return fn(a, b);
+    };
+  };
+};
+
+export const runFn3 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return fn(a, b, c);
+      };
+    };
+  };
+};
+
+export const runFn4 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return fn(a, b, c, d);
+        };
+      };
+    };
+  };
+};
+
+export const runFn5 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return function (e) {
+            return fn(a, b, c, d, e);
+          };
+        };
+      };
+    };
+  };
+};
+
+export const runFn6 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return function (e) {
+            return function (f) {
+              return fn(a, b, c, d, e, f);
+            };
+          };
+        };
+      };
+    };
+  };
+};
+
+export const runFn7 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return function (e) {
+            return function (f) {
+              return function (g) {
+                return fn(a, b, c, d, e, f, g);
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+
+export const runFn8 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return function (e) {
+            return function (f) {
+              return function (g) {
+                return function (h) {
+                  return fn(a, b, c, d, e, f, g, h);
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+
+export const runFn9 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return function (e) {
+            return function (f) {
+              return function (g) {
+                return function (h) {
+                  return function (i) {
+                    return fn(a, b, c, d, e, f, g, h, i);
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+
+export const runFn10 = function (fn) {
+  return function (a) {
+    return function (b) {
+      return function (c) {
+        return function (d) {
+          return function (e) {
+            return function (f) {
+              return function (g) {
+                return function (h) {
+                  return function (i) {
+                    return function (j) {
+                      return fn(a, b, c, d, e, f, g, h, i, j);
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};

package/output-es/Data.Function.Uncurried/index.js

@@ -0,0 +1,5 @@
+import {mkFn0, mkFn10, mkFn2, mkFn3, mkFn4, mkFn5, mkFn6, mkFn7, mkFn8, mkFn9, runFn0, runFn10, runFn2, runFn3, runFn4, runFn5, runFn6, runFn7, runFn8, runFn9} from "./foreign.js";
+const runFn1 = f => f;
+const mkFn1 = f => f;
+export {mkFn1, runFn1};
+export * from "./foreign.js";

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

@@ -0,0 +1,10 @@
+export const arrayMap = function (f) {
+  return function (arr) {
+    var l = arr.length;
+    var result = new Array(l);
+    for (var i = 0; i < l; i++) {
+      result[i] = f(arr[i]);
+    }
+    return result;
+  };
+};

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

@@ -0,0 +1,14 @@
+import * as Control$dSemigroupoid from "../Control.Semigroupoid/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {arrayMap} from "./foreign.js";
+const map = dict => dict.map;
+const mapFlipped = dictFunctor => fa => f => dictFunctor.map(f)(fa);
+const $$void = dictFunctor => dictFunctor.map(v => {});
+const voidLeft = dictFunctor => f => x => dictFunctor.map(v => x)(f);
+const voidRight = dictFunctor => x => dictFunctor.map(v => x);
+const functorProxy = {map: v => v1 => Type$dProxy.Proxy};
+const functorFn = /* #__PURE__ */ (() => ({map: Control$dSemigroupoid.semigroupoidFn.compose}))();
+const functorArray = {map: arrayMap};
+const flap = dictFunctor => ff => x => dictFunctor.map(f => f(x))(ff);
+export {flap, functorArray, functorFn, functorProxy, map, mapFlipped, $$void as void, voidLeft, voidRight};
+export * from "./foreign.js";

package/output-es/Data.Functor.App/index.js

@@ -0,0 +1,87 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const App = x => x;
+const showApp = dictShow => ({show: v => "(App " + dictShow.show(v) + ")"});
+const semigroupApp = dictApply => dictSemigroup => {
+  const append1 = dictSemigroup.append;
+  return {append: v => v1 => dictApply.apply(dictApply.Functor0().map(append1)(v))(v1)};
+};
+const plusApp = dictPlus => dictPlus;
+const newtypeApp = {Coercible0: () => {}};
+const monoidApp = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  return dictMonoid => {
+    const append1 = dictMonoid.Semigroup0().append;
+    const semigroupApp2 = {append: v => v1 => $0.apply($0.Functor0().map(append1)(v))(v1)};
+    return {mempty: dictApplicative.pure(dictMonoid.mempty), Semigroup0: () => semigroupApp2};
+  };
+};
+const monadPlusApp = dictMonadPlus => dictMonadPlus;
+const monadApp = dictMonad => dictMonad;
+const lazyApp = dictLazy => dictLazy;
+const hoistLowerApp = Unsafe$dCoerce.unsafeCoerce;
+const hoistLiftApp = Unsafe$dCoerce.unsafeCoerce;
+const hoistApp = f => v => f(v);
+const functorApp = dictFunctor => dictFunctor;
+const extendApp = dictExtend => dictExtend;
+const eqApp = dictEq1 => dictEq => {
+  const eq11 = dictEq1.eq1(dictEq);
+  return {eq: x => y => eq11(x)(y)};
+};
+const ordApp = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd => {
+    const compare11 = dictOrd1.compare1(dictOrd);
+    const eq11 = $0.eq1(dictOrd.Eq0());
+    const eqApp2 = {eq: x => y => eq11(x)(y)};
+    return {compare: x => y => compare11(x)(y), Eq0: () => eqApp2};
+  };
+};
+const eq1App = dictEq1 => ({eq1: dictEq => dictEq1.eq1(dictEq)});
+const ord1App = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  const $1 = dictOrd1.Eq10();
+  const eq1App1 = {eq1: dictEq => $1.eq1(dictEq)};
+  return {
+    compare1: dictOrd => {
+      const compare11 = dictOrd1.compare1(dictOrd);
+      const eq11 = $0.eq1(dictOrd.Eq0());
+      return (() => {
+        const eqApp2 = {eq: x => y => eq11(x)(y)};
+        return {compare: x => y => compare11(x)(y), Eq0: () => eqApp2};
+      })().compare;
+    },
+    Eq10: () => eq1App1
+  };
+};
+const comonadApp = dictComonad => dictComonad;
+const bindApp = dictBind => dictBind;
+const applyApp = dictApply => dictApply;
+const applicativeApp = dictApplicative => dictApplicative;
+const alternativeApp = dictAlternative => dictAlternative;
+const altApp = dictAlt => dictAlt;
+export {
+  App,
+  altApp,
+  alternativeApp,
+  applicativeApp,
+  applyApp,
+  bindApp,
+  comonadApp,
+  eq1App,
+  eqApp,
+  extendApp,
+  functorApp,
+  hoistApp,
+  hoistLiftApp,
+  hoistLowerApp,
+  lazyApp,
+  monadApp,
+  monadPlusApp,
+  monoidApp,
+  newtypeApp,
+  ord1App,
+  ordApp,
+  plusApp,
+  semigroupApp,
+  showApp
+};

package/output-es/Data.Functor.Clown/index.js

@@ -0,0 +1,24 @@
+const Clown = x => x;
+const showClown = dictShow => ({show: v => "(Clown " + dictShow.show(v) + ")"});
+const profunctorClown = dictContravariant => ({dimap: f => v => v1 => dictContravariant.cmap(f)(v1)});
+const ordClown = dictOrd => dictOrd;
+const newtypeClown = {Coercible0: () => {}};
+const hoistClown = f => v => f(v);
+const functorClown = {map: v => v1 => v1};
+const eqClown = dictEq => dictEq;
+const bifunctorClown = dictFunctor => ({bimap: f => v => v1 => dictFunctor.map(f)(v1)});
+const biapplyClown = dictApply => {
+  const $0 = dictApply.Functor0();
+  const bifunctorClown1 = {bimap: f => v => v1 => $0.map(f)(v1)};
+  return {biapply: v => v1 => dictApply.apply(v)(v1), Bifunctor0: () => bifunctorClown1};
+};
+const biapplicativeClown = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const $1 = $0.Functor0();
+  const biapplyClown1 = (() => {
+    const bifunctorClown1 = {bimap: f => v => v1 => $1.map(f)(v1)};
+    return {biapply: v => v1 => $0.apply(v)(v1), Bifunctor0: () => bifunctorClown1};
+  })();
+  return {bipure: a => v => dictApplicative.pure(a), Biapply0: () => biapplyClown1};
+};
+export {Clown, biapplicativeClown, biapplyClown, bifunctorClown, eqClown, functorClown, hoistClown, newtypeClown, ordClown, profunctorClown, showClown};