@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,131 @@
+const Compose = x => x;
+const showCompose = dictShow => ({show: v => "(Compose " + dictShow.show(v) + ")"});
+const newtypeCompose = {Coercible0: () => {}};
+const functorCompose = dictFunctor => dictFunctor1 => ({map: f => v => dictFunctor.map(dictFunctor1.map(f))(v)});
+const eqCompose = dictEq1 => dictEq11 => dictEq => {
+  const eq11 = dictEq1.eq1((() => {
+    const eq11 = dictEq11.eq1(dictEq);
+    return {eq: x => y => eq11(x)(y)};
+  })());
+  return {eq: v => v1 => eq11(v)(v1)};
+};
+const ordCompose = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd11 => {
+    const $1 = dictOrd11.Eq10();
+    const $2 = dictOrd11.Eq10();
+    return dictOrd => {
+      const compare11 = dictOrd1.compare1((() => {
+        const compare11 = dictOrd11.compare1(dictOrd);
+        const eq11 = $1.eq1(dictOrd.Eq0());
+        const eqApp2 = {eq: x => y => eq11(x)(y)};
+        return {compare: x => y => compare11(x)(y), Eq0: () => eqApp2};
+      })());
+      const eq11 = $0.eq1((() => {
+        const eq11 = $2.eq1(dictOrd.Eq0());
+        return {eq: x => y => eq11(x)(y)};
+      })());
+      const eqCompose3 = {eq: v => v1 => eq11(v)(v1)};
+      return {compare: v => v1 => compare11(v)(v1), Eq0: () => eqCompose3};
+    };
+  };
+};
+const eq1Compose = dictEq1 => dictEq11 => (
+  {
+    eq1: dictEq => dictEq1.eq1((() => {
+      const eq11 = dictEq11.eq1(dictEq);
+      return {eq: x => y => eq11(x)(y)};
+    })())
+  }
+);
+const ord1Compose = dictOrd1 => {
+  const ordCompose1 = ordCompose(dictOrd1);
+  const $0 = dictOrd1.Eq10();
+  return dictOrd11 => {
+    const ordCompose2 = ordCompose1(dictOrd11);
+    const $1 = dictOrd11.Eq10();
+    const eq1Compose2 = {
+      eq1: dictEq => $0.eq1((() => {
+        const eq11 = $1.eq1(dictEq);
+        return {eq: x => y => eq11(x)(y)};
+      })())
+    };
+    return {compare1: dictOrd => ordCompose2(dictOrd).compare, Eq10: () => eq1Compose2};
+  };
+};
+const bihoistCompose = dictFunctor => natF => natG => v => natF(dictFunctor.map(natG)(v));
+const applyCompose = dictApply => {
+  const Functor0 = dictApply.Functor0();
+  return dictApply1 => {
+    const apply1 = dictApply1.apply;
+    const $0 = dictApply1.Functor0();
+    const functorCompose2 = {map: f => v => Functor0.map($0.map(f))(v)};
+    return {apply: v => v1 => dictApply.apply(Functor0.map(apply1)(v))(v1), Functor0: () => functorCompose2};
+  };
+};
+const applicativeCompose = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const Functor0 = $0.Functor0();
+  return dictApplicative1 => {
+    const $1 = dictApplicative1.Apply0();
+    const apply1 = $1.apply;
+    const applyCompose2 = (() => {
+      const $2 = $1.Functor0();
+      const functorCompose2 = {map: f => v => Functor0.map($2.map(f))(v)};
+      return {apply: v => v1 => $0.apply(Functor0.map(apply1)(v))(v1), Functor0: () => functorCompose2};
+    })();
+    return {pure: x => dictApplicative.pure(dictApplicative1.pure(x)), Apply0: () => applyCompose2};
+  };
+};
+const altCompose = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  return dictFunctor => {
+    const functorCompose2 = {map: f => v => $0.map(dictFunctor.map(f))(v)};
+    return {alt: v => v1 => dictAlt.alt(v)(v1), Functor0: () => functorCompose2};
+  };
+};
+const plusCompose = dictPlus => {
+  const empty = dictPlus.empty;
+  const $0 = dictPlus.Alt0();
+  const $1 = $0.Functor0();
+  return dictFunctor => {
+    const functorCompose2 = {map: f => v => $1.map(dictFunctor.map(f))(v)};
+    const altCompose2 = {alt: v => v1 => $0.alt(v)(v1), Functor0: () => functorCompose2};
+    return {empty, Alt0: () => altCompose2};
+  };
+};
+const alternativeCompose = dictAlternative => {
+  const applicativeCompose1 = applicativeCompose(dictAlternative.Applicative0());
+  const $0 = dictAlternative.Plus1();
+  const empty = $0.empty;
+  const plusCompose1 = (() => {
+    const $1 = $0.Alt0();
+    const $2 = $1.Functor0();
+    return dictFunctor => {
+      const functorCompose2 = {map: f => v => $2.map(dictFunctor.map(f))(v)};
+      const altCompose2 = {alt: v => v1 => $1.alt(v)(v1), Functor0: () => functorCompose2};
+      return {empty, Alt0: () => altCompose2};
+    };
+  })();
+  return dictApplicative => {
+    const applicativeCompose2 = applicativeCompose1(dictApplicative);
+    const plusCompose2 = plusCompose1(dictApplicative.Apply0().Functor0());
+    return {Applicative0: () => applicativeCompose2, Plus1: () => plusCompose2};
+  };
+};
+export {
+  Compose,
+  altCompose,
+  alternativeCompose,
+  applicativeCompose,
+  applyCompose,
+  bihoistCompose,
+  eq1Compose,
+  eqCompose,
+  functorCompose,
+  newtypeCompose,
+  ord1Compose,
+  ordCompose,
+  plusCompose,
+  showCompose
+};

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

@@ -0,0 +1,7 @@
+import * as Data$dVoid from "../Data.Void/index.js";
+const contravariantConst = {cmap: v => v1 => v1};
+const cmap = dict => dict.cmap;
+const cmapFlipped = dictContravariant => x => f => dictContravariant.cmap(f)(x);
+const coerce = dictContravariant => dictFunctor => a => dictFunctor.map(Data$dVoid.absurd)(dictContravariant.cmap(Data$dVoid.absurd)(a));
+const imapC = dictContravariant => v => f => dictContravariant.cmap(f);
+export {cmap, cmapFlipped, coerce, contravariantConst, imapC};

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

@@ -0,0 +1,171 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const Coproduct = x => x;
+const showCoproduct = dictShow => dictShow1 => (
+  {
+    show: v => {
+      if (v.tag === "Left") { return "(left " + dictShow.show(v._1) + ")"; }
+      if (v.tag === "Right") { return "(right " + dictShow1.show(v._1) + ")"; }
+      $runtime.fail();
+    }
+  }
+);
+const right = ga => Data$dEither.$Either("Right", ga);
+const newtypeCoproduct = {Coercible0: () => {}};
+const left = fa => Data$dEither.$Either("Left", fa);
+const functorCoproduct = dictFunctor => dictFunctor1 => (
+  {
+    map: f => v => {
+      const $0 = dictFunctor.map(f);
+      const $1 = dictFunctor1.map(f);
+      if (v.tag === "Left") { return Data$dEither.$Either("Left", $0(v._1)); }
+      if (v.tag === "Right") { return Data$dEither.$Either("Right", $1(v._1)); }
+      $runtime.fail();
+    }
+  }
+);
+const eq1Coproduct = dictEq1 => dictEq11 => (
+  {
+    eq1: dictEq => {
+      const eq12 = dictEq1.eq1(dictEq);
+      const eq13 = dictEq11.eq1(dictEq);
+      return v => v1 => {
+        if (v.tag === "Left") { return v1.tag === "Left" && eq12(v._1)(v1._1); }
+        return v.tag === "Right" && v1.tag === "Right" && eq13(v._1)(v1._1);
+      };
+    }
+  }
+);
+const eqCoproduct = dictEq1 => dictEq11 => dictEq => (
+  {
+    eq: (() => {
+      const eq12 = dictEq1.eq1(dictEq);
+      const eq13 = dictEq11.eq1(dictEq);
+      return v => v1 => {
+        if (v.tag === "Left") { return v1.tag === "Left" && eq12(v._1)(v1._1); }
+        return v.tag === "Right" && v1.tag === "Right" && eq13(v._1)(v1._1);
+      };
+    })()
+  }
+);
+const ord1Coproduct = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd11 => {
+    const $1 = dictOrd11.Eq10();
+    const eq1Coproduct2 = {
+      eq1: dictEq => {
+        const eq12 = $0.eq1(dictEq);
+        const eq13 = $1.eq1(dictEq);
+        return v => v1 => {
+          if (v.tag === "Left") { return v1.tag === "Left" && eq12(v._1)(v1._1); }
+          return v.tag === "Right" && v1.tag === "Right" && eq13(v._1)(v1._1);
+        };
+      }
+    };
+    return {
+      compare1: dictOrd => {
+        const compare12 = dictOrd1.compare1(dictOrd);
+        const compare13 = dictOrd11.compare1(dictOrd);
+        return v => v1 => {
+          if (v.tag === "Left") {
+            if (v1.tag === "Left") { return compare12(v._1)(v1._1); }
+            return Data$dOrdering.LT;
+          }
+          if (v1.tag === "Left") { return Data$dOrdering.GT; }
+          if (v.tag === "Right" && v1.tag === "Right") { return compare13(v._1)(v1._1); }
+          $runtime.fail();
+        };
+      },
+      Eq10: () => eq1Coproduct2
+    };
+  };
+};
+const ordCoproduct = dictOrd1 => {
+  const ord1Coproduct1 = ord1Coproduct(dictOrd1);
+  const $0 = dictOrd1.Eq10();
+  return dictOrd11 => {
+    const $1 = dictOrd11.Eq10();
+    return dictOrd => {
+      const $2 = dictOrd.Eq0();
+      const eqCoproduct3 = {
+        eq: (() => {
+          const eq12 = $0.eq1($2);
+          const eq13 = $1.eq1($2);
+          return v => v1 => {
+            if (v.tag === "Left") { return v1.tag === "Left" && eq12(v._1)(v1._1); }
+            return v.tag === "Right" && v1.tag === "Right" && eq13(v._1)(v1._1);
+          };
+        })()
+      };
+      return {compare: ord1Coproduct1(dictOrd11).compare1(dictOrd), Eq0: () => eqCoproduct3};
+    };
+  };
+};
+const coproduct = v => v1 => v2 => {
+  if (v2.tag === "Left") { return v(v2._1); }
+  if (v2.tag === "Right") { return v1(v2._1); }
+  $runtime.fail();
+};
+const extendCoproduct = dictExtend => {
+  const $0 = dictExtend.Functor0();
+  return dictExtend1 => {
+    const $1 = dictExtend1.Functor0();
+    const functorCoproduct2 = {
+      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 {
+      extend: f => {
+        const $2 = dictExtend.extend(x => f(Data$dEither.$Either("Left", x)));
+        const $3 = dictExtend1.extend(x => f(Data$dEither.$Either("Right", x)));
+        return v2 => {
+          if (v2.tag === "Left") { return Data$dEither.$Either("Left", $2(v2._1)); }
+          if (v2.tag === "Right") { return Data$dEither.$Either("Right", $3(v2._1)); }
+          $runtime.fail();
+        };
+      },
+      Functor0: () => functorCoproduct2
+    };
+  };
+};
+const comonadCoproduct = dictComonad => {
+  const extendCoproduct1 = extendCoproduct(dictComonad.Extend0());
+  return dictComonad1 => {
+    const extendCoproduct2 = extendCoproduct1(dictComonad1.Extend0());
+    return {
+      extract: v2 => {
+        if (v2.tag === "Left") { return dictComonad.extract(v2._1); }
+        if (v2.tag === "Right") { return dictComonad1.extract(v2._1); }
+        $runtime.fail();
+      },
+      Extend0: () => extendCoproduct2
+    };
+  };
+};
+const bihoistCoproduct = natF => natG => v => {
+  if (v.tag === "Left") { return Data$dEither.$Either("Left", natF(v._1)); }
+  if (v.tag === "Right") { return Data$dEither.$Either("Right", natG(v._1)); }
+  $runtime.fail();
+};
+export {
+  Coproduct,
+  bihoistCoproduct,
+  comonadCoproduct,
+  coproduct,
+  eq1Coproduct,
+  eqCoproduct,
+  extendCoproduct,
+  functorCoproduct,
+  left,
+  newtypeCoproduct,
+  ord1Coproduct,
+  ordCoproduct,
+  right,
+  showCoproduct
+};

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

@@ -0,0 +1,25 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+const prj = dict => dict.prj;
+const injectReflexive = {inj: x => x, prj: Data$dMaybe.Just};
+const injectLeft = {
+  inj: x => Data$dEither.$Either("Left", x),
+  prj: v2 => {
+    if (v2.tag === "Left") { return Data$dMaybe.$Maybe("Just", v2._1); }
+    if (v2.tag === "Right") { return Data$dMaybe.Nothing; }
+    $runtime.fail();
+  }
+};
+const inj = dict => dict.inj;
+const injectRight = dictInject => (
+  {
+    inj: x => Data$dEither.$Either("Right", dictInject.inj(x)),
+    prj: v2 => {
+      if (v2.tag === "Left") { return Data$dMaybe.Nothing; }
+      if (v2.tag === "Right") { return dictInject.prj(v2._1); }
+      $runtime.fail();
+    }
+  }
+);
+export {inj, injectLeft, injectReflexive, injectRight, prj};