@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,127 @@
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const Product = x => x;
+const showProduct = dictShow => dictShow1 => ({show: v => "(product " + dictShow.show(v._1) + " " + dictShow1.show(v._2) + ")"});
+const product = fa => ga => Data$dTuple.$Tuple(fa, ga);
+const newtypeProduct = {Coercible0: () => {}};
+const functorProduct = dictFunctor => dictFunctor1 => ({map: f => v => Data$dTuple.$Tuple(dictFunctor.map(f)(v._1), dictFunctor1.map(f)(v._2))});
+const eq1Product = dictEq1 => dictEq11 => (
+  {
+    eq1: dictEq => {
+      const eq12 = dictEq1.eq1(dictEq);
+      const eq13 = dictEq11.eq1(dictEq);
+      return v => v1 => eq12(v._1)(v1._1) && eq13(v._2)(v1._2);
+    }
+  }
+);
+const eqProduct = dictEq1 => dictEq11 => dictEq => (
+  {
+    eq: (() => {
+      const eq12 = dictEq1.eq1(dictEq);
+      const eq13 = dictEq11.eq1(dictEq);
+      return v => v1 => eq12(v._1)(v1._1) && eq13(v._2)(v1._2);
+    })()
+  }
+);
+const ord1Product = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd11 => {
+    const $1 = dictOrd11.Eq10();
+    const eq1Product2 = {
+      eq1: dictEq => {
+        const eq12 = $0.eq1(dictEq);
+        const eq13 = $1.eq1(dictEq);
+        return v => v1 => eq12(v._1)(v1._1) && eq13(v._2)(v1._2);
+      }
+    };
+    return {
+      compare1: dictOrd => {
+        const compare12 = dictOrd1.compare1(dictOrd);
+        const compare13 = dictOrd11.compare1(dictOrd);
+        return v => v1 => {
+          const v2 = compare12(v._1)(v1._1);
+          if (v2 === "EQ") { return compare13(v._2)(v1._2); }
+          return v2;
+        };
+      },
+      Eq10: () => eq1Product2
+    };
+  };
+};
+const ordProduct = dictOrd1 => {
+  const ord1Product1 = ord1Product(dictOrd1);
+  const $0 = dictOrd1.Eq10();
+  return dictOrd11 => {
+    const $1 = dictOrd11.Eq10();
+    return dictOrd => {
+      const $2 = dictOrd.Eq0();
+      const eqProduct3 = {
+        eq: (() => {
+          const eq12 = $0.eq1($2);
+          const eq13 = $1.eq1($2);
+          return v => v1 => eq12(v._1)(v1._1) && eq13(v._2)(v1._2);
+        })()
+      };
+      return {compare: ord1Product1(dictOrd11).compare1(dictOrd), Eq0: () => eqProduct3};
+    };
+  };
+};
+const bihoistProduct = natF => natG => v => Data$dTuple.$Tuple(natF(v._1), natG(v._2));
+const applyProduct = dictApply => {
+  const $0 = dictApply.Functor0();
+  return dictApply1 => {
+    const $1 = dictApply1.Functor0();
+    const functorProduct2 = {map: f => v => Data$dTuple.$Tuple($0.map(f)(v._1), $1.map(f)(v._2))};
+    return {apply: v => v1 => Data$dTuple.$Tuple(dictApply.apply(v._1)(v1._1), dictApply1.apply(v._2)(v1._2)), Functor0: () => functorProduct2};
+  };
+};
+const bindProduct = dictBind => {
+  const $0 = dictBind.Apply0();
+  const $1 = $0.Functor0();
+  return dictBind1 => {
+    const $2 = dictBind1.Apply0();
+    const $3 = $2.Functor0();
+    const applyProduct2 = (() => {
+      const functorProduct2 = {map: f => v => Data$dTuple.$Tuple($1.map(f)(v._1), $3.map(f)(v._2))};
+      return {apply: v => v1 => Data$dTuple.$Tuple($0.apply(v._1)(v1._1), $2.apply(v._2)(v1._2)), Functor0: () => functorProduct2};
+    })();
+    return {bind: v => f => Data$dTuple.$Tuple(dictBind.bind(v._1)(x => f(x)._1), dictBind1.bind(v._2)(x => f(x)._2)), Apply0: () => applyProduct2};
+  };
+};
+const applicativeProduct = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const $1 = $0.Functor0();
+  return dictApplicative1 => {
+    const $2 = dictApplicative1.Apply0();
+    const $3 = $2.Functor0();
+    const applyProduct2 = (() => {
+      const functorProduct2 = {map: f => v => Data$dTuple.$Tuple($1.map(f)(v._1), $3.map(f)(v._2))};
+      return {apply: v => v1 => Data$dTuple.$Tuple($0.apply(v._1)(v1._1), $2.apply(v._2)(v1._2)), Functor0: () => functorProduct2};
+    })();
+    return {pure: a => Data$dTuple.$Tuple(dictApplicative.pure(a), dictApplicative1.pure(a)), Apply0: () => applyProduct2};
+  };
+};
+const monadProduct = dictMonad => {
+  const applicativeProduct1 = applicativeProduct(dictMonad.Applicative0());
+  const bindProduct1 = bindProduct(dictMonad.Bind1());
+  return dictMonad1 => {
+    const applicativeProduct2 = applicativeProduct1(dictMonad1.Applicative0());
+    const bindProduct2 = bindProduct1(dictMonad1.Bind1());
+    return {Applicative0: () => applicativeProduct2, Bind1: () => bindProduct2};
+  };
+};
+export {
+  Product,
+  applicativeProduct,
+  applyProduct,
+  bihoistProduct,
+  bindProduct,
+  eq1Product,
+  eqProduct,
+  functorProduct,
+  monadProduct,
+  newtypeProduct,
+  ord1Product,
+  ordProduct,
+  product,
+  showProduct
+};

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

@@ -0,0 +1,46 @@
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const product9 = 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 product8 = 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 product7 = 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 product6 = 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 product5 = 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 product4 = a => b => c => d => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, Data$dTuple.$Tuple(d, undefined))));
+const product3 = a => b => c => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, Data$dTuple.$Tuple(c, undefined)));
+const product2 = a => b => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, undefined));
+const product10 = 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 product1 = a => Data$dTuple.$Tuple(a, undefined);
+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;
+export {get1, get10, get2, get3, get4, get5, get6, get7, get8, get9, product1, product10, product2, product3, product4, product5, product6, product7, product8, product9};

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

@@ -0,0 +1,46 @@
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const $Product2 = (_1, _2) => ({tag: "Product2", _1, _2});
+const Product2 = value0 => value1 => $Product2(value0, value1);
+const showProduct2 = dictShow => dictShow1 => ({show: v => "(Product2 " + dictShow.show(v._1) + " " + dictShow1.show(v._2) + ")"});
+const profunctorProduct2 = dictProfunctor => dictProfunctor1 => ({dimap: f => g => v => $Product2(dictProfunctor.dimap(f)(g)(v._1), dictProfunctor1.dimap(f)(g)(v._2))});
+const functorProduct2 = dictFunctor => dictFunctor1 => ({map: f => v => $Product2(dictFunctor.map(f)(v._1), dictFunctor1.map(f)(v._2))});
+const eqProduct2 = dictEq => dictEq1 => ({eq: x => y => dictEq.eq(x._1)(y._1) && dictEq1.eq(x._2)(y._2)});
+const ordProduct2 = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  return dictOrd1 => {
+    const $1 = dictOrd1.Eq0();
+    const eqProduct22 = {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: () => eqProduct22
+    };
+  };
+};
+const bifunctorProduct2 = dictBifunctor => dictBifunctor1 => ({bimap: f => g => v => $Product2(dictBifunctor.bimap(f)(g)(v._1), dictBifunctor1.bimap(f)(g)(v._2))});
+const biapplyProduct2 = dictBiapply => {
+  const $0 = dictBiapply.Bifunctor0();
+  return dictBiapply1 => {
+    const $1 = dictBiapply1.Bifunctor0();
+    const bifunctorProduct22 = {bimap: f => g => v => $Product2($0.bimap(f)(g)(v._1), $1.bimap(f)(g)(v._2))};
+    return {biapply: v => v1 => $Product2(dictBiapply.biapply(v._1)(v1._1), dictBiapply1.biapply(v._2)(v1._2)), Bifunctor0: () => bifunctorProduct22};
+  };
+};
+const biapplicativeProduct2 = dictBiapplicative => {
+  const $0 = dictBiapplicative.Biapply0();
+  const $1 = $0.Bifunctor0();
+  return dictBiapplicative1 => {
+    const $2 = dictBiapplicative1.Biapply0();
+    const $3 = $2.Bifunctor0();
+    const biapplyProduct22 = (() => {
+      const bifunctorProduct22 = {bimap: f => g => v => $Product2($1.bimap(f)(g)(v._1), $3.bimap(f)(g)(v._2))};
+      return {biapply: v => v1 => $Product2($0.biapply(v._1)(v1._1), $2.biapply(v._2)(v1._2)), Bifunctor0: () => bifunctorProduct22};
+    })();
+    return {bipure: a => b => $Product2(dictBiapplicative.bipure(a)(b), dictBiapplicative1.bipure(a)(b)), Biapply0: () => biapplyProduct22};
+  };
+};
+export {$Product2, Product2, biapplicativeProduct2, biapplyProduct2, bifunctorProduct2, eqProduct2, functorProduct2, ordProduct2, profunctorProduct2, showProduct2};

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

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

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

@@ -0,0 +1,147 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dConst from "../Data.Const/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dMonoid$dAdditive from "../Data.Monoid.Additive/index.js";
+import * as Data$dMonoid$dConj from "../Data.Monoid.Conj/index.js";
+import * as Data$dMonoid$dDisj from "../Data.Monoid.Disj/index.js";
+import * as Data$dMonoid$dDual from "../Data.Monoid.Dual/index.js";
+import * as Data$dMonoid$dMultiplicative from "../Data.Monoid.Multiplicative/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import {mapWithIndexArray} from "./foreign.js";
+const mapWithIndex = dict => dict.mapWithIndex;
+const mapDefault = dictFunctorWithIndex => f => dictFunctorWithIndex.mapWithIndex(v => f);
+const functorWithIndexTuple = {
+  mapWithIndex: f => {
+    const $0 = f();
+    return m => Data$dTuple.$Tuple(m._1, $0(m._2));
+  },
+  Functor0: () => Data$dTuple.functorTuple
+};
+const functorWithIndexProduct = dictFunctorWithIndex => {
+  const $0 = dictFunctorWithIndex.Functor0();
+  return dictFunctorWithIndex1 => {
+    const $1 = dictFunctorWithIndex1.Functor0();
+    const functorProduct1 = {map: f => v => Data$dTuple.$Tuple($0.map(f)(v._1), $1.map(f)(v._2))};
+    return {
+      mapWithIndex: f => v => Data$dTuple.$Tuple(
+        dictFunctorWithIndex.mapWithIndex(x => f(Data$dEither.$Either("Left", x)))(v._1),
+        dictFunctorWithIndex1.mapWithIndex(x => f(Data$dEither.$Either("Right", x)))(v._2)
+      ),
+      Functor0: () => functorProduct1
+    };
+  };
+};
+const functorWithIndexMultiplicative = {mapWithIndex: f => f(), Functor0: () => Data$dMonoid$dMultiplicative.functorMultiplicative};
+const functorWithIndexMaybe = {
+  mapWithIndex: f => {
+    const $0 = f();
+    return v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0(v1._1)); }
+      return Data$dMaybe.Nothing;
+    };
+  },
+  Functor0: () => Data$dMaybe.functorMaybe
+};
+const functorWithIndexLast = {
+  mapWithIndex: f => {
+    const $0 = f();
+    return v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0(v1._1)); }
+      return Data$dMaybe.Nothing;
+    };
+  },
+  Functor0: () => Data$dMaybe.functorMaybe
+};
+const functorWithIndexIdentity = {mapWithIndex: f => v => f()(v), Functor0: () => Data$dIdentity.functorIdentity};
+const functorWithIndexFirst = {
+  mapWithIndex: f => {
+    const $0 = f();
+    return v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0(v1._1)); }
+      return Data$dMaybe.Nothing;
+    };
+  },
+  Functor0: () => Data$dMaybe.functorMaybe
+};
+const functorWithIndexEither = {
+  mapWithIndex: f => {
+    const $0 = f();
+    return m => {
+      if (m.tag === "Left") { return Data$dEither.$Either("Left", m._1); }
+      if (m.tag === "Right") { return Data$dEither.$Either("Right", $0(m._1)); }
+      $runtime.fail();
+    };
+  },
+  Functor0: () => Data$dEither.functorEither
+};
+const functorWithIndexDual = {mapWithIndex: f => f(), Functor0: () => Data$dMonoid$dDual.functorDual};
+const functorWithIndexDisj = {mapWithIndex: f => f(), Functor0: () => Data$dMonoid$dDisj.functorDisj};
+const functorWithIndexCoproduct = dictFunctorWithIndex => {
+  const $0 = dictFunctorWithIndex.Functor0();
+  return dictFunctorWithIndex1 => {
+    const $1 = dictFunctorWithIndex1.Functor0();
+    const functorCoproduct1 = {
+      map: f => v => {
+        const $2 = $0.map(f);
+        const $3 = $1.map(f);
+        if (v.tag === "Left") { return Data$dEither.$Either("Left", $2(v._1)); }
+        if (v.tag === "Right") { return Data$dEither.$Either("Right", $3(v._1)); }
+        $runtime.fail();
+      }
+    };
+    return {
+      mapWithIndex: f => v => {
+        const $2 = dictFunctorWithIndex.mapWithIndex(x => f(Data$dEither.$Either("Left", x)));
+        const $3 = dictFunctorWithIndex1.mapWithIndex(x => f(Data$dEither.$Either("Right", x)));
+        if (v.tag === "Left") { return Data$dEither.$Either("Left", $2(v._1)); }
+        if (v.tag === "Right") { return Data$dEither.$Either("Right", $3(v._1)); }
+        $runtime.fail();
+      },
+      Functor0: () => functorCoproduct1
+    };
+  };
+};
+const functorWithIndexConst = {mapWithIndex: v => v1 => v1, Functor0: () => Data$dConst.functorConst};
+const functorWithIndexConj = {mapWithIndex: f => f(), Functor0: () => Data$dMonoid$dConj.functorConj};
+const functorWithIndexCompose = dictFunctorWithIndex => {
+  const $0 = dictFunctorWithIndex.Functor0();
+  return dictFunctorWithIndex1 => {
+    const $1 = dictFunctorWithIndex1.Functor0();
+    const functorCompose1 = {map: f => v => $0.map($1.map(f))(v)};
+    return {
+      mapWithIndex: f => v => dictFunctorWithIndex.mapWithIndex(x => dictFunctorWithIndex1.mapWithIndex(b => f(Data$dTuple.$Tuple(x, b))))(v),
+      Functor0: () => functorCompose1
+    };
+  };
+};
+const functorWithIndexArray = {mapWithIndex: mapWithIndexArray, Functor0: () => Data$dFunctor.functorArray};
+const functorWithIndexApp = dictFunctorWithIndex => {
+  const $0 = dictFunctorWithIndex.Functor0();
+  return {mapWithIndex: f => v => dictFunctorWithIndex.mapWithIndex(f)(v), Functor0: () => $0};
+};
+const functorWithIndexAdditive = {mapWithIndex: f => f(), Functor0: () => Data$dMonoid$dAdditive.functorAdditive};
+export {
+  functorWithIndexAdditive,
+  functorWithIndexApp,
+  functorWithIndexArray,
+  functorWithIndexCompose,
+  functorWithIndexConj,
+  functorWithIndexConst,
+  functorWithIndexCoproduct,
+  functorWithIndexDisj,
+  functorWithIndexDual,
+  functorWithIndexEither,
+  functorWithIndexFirst,
+  functorWithIndexIdentity,
+  functorWithIndexLast,
+  functorWithIndexMaybe,
+  functorWithIndexMultiplicative,
+  functorWithIndexProduct,
+  functorWithIndexTuple,
+  mapDefault,
+  mapWithIndex
+};
+export * from "./foreign.js";

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

@@ -0,0 +1,31 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+const $NoArguments = () => ({tag: "NoArguments"});
+const $Product = (_1, _2) => ({tag: "Product", _1, _2});
+const $Sum = (tag, _1) => ({tag, _1});
+const Inl = value0 => $Sum("Inl", value0);
+const Inr = value0 => $Sum("Inr", value0);
+const Product = value0 => value1 => $Product(value0, value1);
+const NoArguments = /* #__PURE__ */ $NoArguments();
+const Constructor = x => x;
+const Argument = x => x;
+const to = dict => dict.to;
+const showSum = dictShow => dictShow1 => (
+  {
+    show: v => {
+      if (v.tag === "Inl") { return "(Inl " + dictShow.show(v._1) + ")"; }
+      if (v.tag === "Inr") { return "(Inr " + dictShow1.show(v._1) + ")"; }
+      $runtime.fail();
+    }
+  }
+);
+const showProduct = dictShow => dictShow1 => ({show: v => "(Product " + dictShow.show(v._1) + " " + dictShow1.show(v._2) + ")"});
+const showNoArguments = {show: v => "NoArguments"};
+const showConstructor = dictIsSymbol => dictShow => (
+  {show: v => "(Constructor @" + Data$dShow.showStringImpl(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy)) + " " + dictShow.show(v) + ")"}
+);
+const showArgument = dictShow => ({show: v => "(Argument " + dictShow.show(v) + ")"});
+const repOf = dictGeneric => v => Type$dProxy.Proxy;
+const from = dict => dict.from;
+export {$NoArguments, $Product, $Sum, Argument, Constructor, Inl, Inr, NoArguments, Product, from, repOf, showArgument, showConstructor, showNoArguments, showProduct, showSum, to};