@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,253 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const $Maybe = (tag, _1) => ({tag, _1});
+const Nothing = /* #__PURE__ */ $Maybe("Nothing");
+const Just = value0 => $Maybe("Just", value0);
+const showMaybe = dictShow => (
+  {
+    show: v => {
+      if (v.tag === "Just") { return "(Just " + dictShow.show(v._1) + ")"; }
+      if (v.tag === "Nothing") { return "Nothing"; }
+      $runtime.fail();
+    }
+  }
+);
+const semigroupMaybe = dictSemigroup => (
+  {
+    append: v => v1 => {
+      if (v.tag === "Nothing") { return v1; }
+      if (v1.tag === "Nothing") { return v; }
+      if (v.tag === "Just" && v1.tag === "Just") { return $Maybe("Just", dictSemigroup.append(v._1)(v1._1)); }
+      $runtime.fail();
+    }
+  }
+);
+const optional = dictAlt => dictApplicative => a => dictAlt.alt(dictAlt.Functor0().map(Just)(a))(dictApplicative.pure(Nothing));
+const monoidMaybe = dictSemigroup => {
+  const semigroupMaybe1 = {
+    append: v => v1 => {
+      if (v.tag === "Nothing") { return v1; }
+      if (v1.tag === "Nothing") { return v; }
+      if (v.tag === "Just" && v1.tag === "Just") { return $Maybe("Just", dictSemigroup.append(v._1)(v1._1)); }
+      $runtime.fail();
+    }
+  };
+  return {mempty: Nothing, Semigroup0: () => semigroupMaybe1};
+};
+const maybe$p = v => v1 => v2 => {
+  if (v2.tag === "Nothing") { return v(); }
+  if (v2.tag === "Just") { return v1(v2._1); }
+  $runtime.fail();
+};
+const maybe = v => v1 => v2 => {
+  if (v2.tag === "Nothing") { return v; }
+  if (v2.tag === "Just") { return v1(v2._1); }
+  $runtime.fail();
+};
+const isNothing = v2 => {
+  if (v2.tag === "Nothing") { return true; }
+  if (v2.tag === "Just") { return false; }
+  $runtime.fail();
+};
+const isJust = v2 => {
+  if (v2.tag === "Nothing") { return false; }
+  if (v2.tag === "Just") { return true; }
+  $runtime.fail();
+};
+const genericMaybe = {
+  to: x => {
+    if (x.tag === "Inl") { return Nothing; }
+    if (x.tag === "Inr") { return $Maybe("Just", x._1); }
+    $runtime.fail();
+  },
+  from: x => {
+    if (x.tag === "Nothing") { return Data$dGeneric$dRep.$Sum("Inl", Data$dGeneric$dRep.NoArguments); }
+    if (x.tag === "Just") { return Data$dGeneric$dRep.$Sum("Inr", x._1); }
+    $runtime.fail();
+  }
+};
+const functorMaybe = {
+  map: v => v1 => {
+    if (v1.tag === "Just") { return $Maybe("Just", v(v1._1)); }
+    return Nothing;
+  }
+};
+const invariantMaybe = {
+  imap: f => v => v1 => {
+    if (v1.tag === "Just") { return $Maybe("Just", f(v1._1)); }
+    return Nothing;
+  }
+};
+const fromMaybe$p = a => v2 => {
+  if (v2.tag === "Nothing") { return a(); }
+  if (v2.tag === "Just") { return v2._1; }
+  $runtime.fail();
+};
+const fromMaybe = a => v2 => {
+  if (v2.tag === "Nothing") { return a; }
+  if (v2.tag === "Just") { return v2._1; }
+  $runtime.fail();
+};
+const fromJust = () => v => {
+  if (v.tag === "Just") { return v._1; }
+  $runtime.fail();
+};
+const extendMaybe = {
+  extend: v => v1 => {
+    if (v1.tag === "Nothing") { return Nothing; }
+    return $Maybe("Just", v(v1));
+  },
+  Functor0: () => functorMaybe
+};
+const eqMaybe = dictEq => (
+  {
+    eq: x => y => {
+      if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+      return x.tag === "Just" && y.tag === "Just" && dictEq.eq(x._1)(y._1);
+    }
+  }
+);
+const ordMaybe = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  const eqMaybe1 = {
+    eq: x => y => {
+      if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+      return x.tag === "Just" && y.tag === "Just" && $0.eq(x._1)(y._1);
+    }
+  };
+  return {
+    compare: x => y => {
+      if (x.tag === "Nothing") {
+        if (y.tag === "Nothing") { return Data$dOrdering.EQ; }
+        return Data$dOrdering.LT;
+      }
+      if (y.tag === "Nothing") { return Data$dOrdering.GT; }
+      if (x.tag === "Just" && y.tag === "Just") { return dictOrd.compare(x._1)(y._1); }
+      $runtime.fail();
+    },
+    Eq0: () => eqMaybe1
+  };
+};
+const eq1Maybe = {
+  eq1: dictEq => x => y => {
+    if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+    return x.tag === "Just" && y.tag === "Just" && dictEq.eq(x._1)(y._1);
+  }
+};
+const ord1Maybe = {
+  compare1: dictOrd => x => y => {
+    if (x.tag === "Nothing") {
+      if (y.tag === "Nothing") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y.tag === "Nothing") { return Data$dOrdering.GT; }
+    if (x.tag === "Just" && y.tag === "Just") { return dictOrd.compare(x._1)(y._1); }
+    $runtime.fail();
+  },
+  Eq10: () => eq1Maybe
+};
+const boundedMaybe = dictBounded => {
+  const $0 = dictBounded.Ord0();
+  const $1 = $0.Eq0();
+  const ordMaybe1 = (() => {
+    const eqMaybe1 = {
+      eq: x => y => {
+        if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+        return x.tag === "Just" && y.tag === "Just" && $1.eq(x._1)(y._1);
+      }
+    };
+    return {
+      compare: x => y => {
+        if (x.tag === "Nothing") {
+          if (y.tag === "Nothing") { return Data$dOrdering.EQ; }
+          return Data$dOrdering.LT;
+        }
+        if (y.tag === "Nothing") { return Data$dOrdering.GT; }
+        if (x.tag === "Just" && y.tag === "Just") { return $0.compare(x._1)(y._1); }
+        $runtime.fail();
+      },
+      Eq0: () => eqMaybe1
+    };
+  })();
+  return {top: $Maybe("Just", dictBounded.top), bottom: Nothing, Ord0: () => ordMaybe1};
+};
+const applyMaybe = {
+  apply: v => v1 => {
+    if (v.tag === "Just") {
+      if (v1.tag === "Just") { return $Maybe("Just", v._1(v1._1)); }
+      return Nothing;
+    }
+    if (v.tag === "Nothing") { return Nothing; }
+    $runtime.fail();
+  },
+  Functor0: () => functorMaybe
+};
+const bindMaybe = {
+  bind: v => v1 => {
+    if (v.tag === "Just") { return v1(v._1); }
+    if (v.tag === "Nothing") { return Nothing; }
+    $runtime.fail();
+  },
+  Apply0: () => applyMaybe
+};
+const semiringMaybe = dictSemiring => (
+  {
+    zero: Nothing,
+    one: $Maybe("Just", dictSemiring.one),
+    add: v => v1 => {
+      if (v.tag === "Nothing") { return v1; }
+      if (v1.tag === "Nothing") { return v; }
+      if (v.tag === "Just" && v1.tag === "Just") { return $Maybe("Just", dictSemiring.add(v._1)(v1._1)); }
+      $runtime.fail();
+    },
+    mul: x => y => {
+      if (x.tag === "Just" && y.tag === "Just") { return $Maybe("Just", dictSemiring.mul(x._1)(y._1)); }
+      return Nothing;
+    }
+  }
+);
+const applicativeMaybe = {pure: Just, Apply0: () => applyMaybe};
+const monadMaybe = {Applicative0: () => applicativeMaybe, Bind1: () => bindMaybe};
+const altMaybe = {
+  alt: v => v1 => {
+    if (v.tag === "Nothing") { return v1; }
+    return v;
+  },
+  Functor0: () => functorMaybe
+};
+const plusMaybe = {empty: Nothing, Alt0: () => altMaybe};
+const alternativeMaybe = {Applicative0: () => applicativeMaybe, Plus1: () => plusMaybe};
+export {
+  $Maybe,
+  Just,
+  Nothing,
+  altMaybe,
+  alternativeMaybe,
+  applicativeMaybe,
+  applyMaybe,
+  bindMaybe,
+  boundedMaybe,
+  eq1Maybe,
+  eqMaybe,
+  extendMaybe,
+  fromJust,
+  fromMaybe,
+  fromMaybe$p,
+  functorMaybe,
+  genericMaybe,
+  invariantMaybe,
+  isJust,
+  isNothing,
+  maybe,
+  maybe$p,
+  monadMaybe,
+  monoidMaybe,
+  optional,
+  ord1Maybe,
+  ordMaybe,
+  plusMaybe,
+  semigroupMaybe,
+  semiringMaybe,
+  showMaybe
+};

package/output-es/Data.Maybe.First/index.js

@@ -0,0 +1,85 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const First = x => x;
+const showFirst = dictShow => (
+  {
+    show: v => {
+      if (v.tag === "Just") { return "First ((Just " + dictShow.show(v._1) + "))"; }
+      if (v.tag === "Nothing") { return "First (Nothing)"; }
+      $runtime.fail();
+    }
+  }
+);
+const semigroupFirst = {
+  append: v => v1 => {
+    if (v.tag === "Just") { return v; }
+    return v1;
+  }
+};
+const ordFirst = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  const eqMaybe1 = {
+    eq: x => y => {
+      if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+      return x.tag === "Just" && y.tag === "Just" && $0.eq(x._1)(y._1);
+    }
+  };
+  return {
+    compare: x => y => {
+      if (x.tag === "Nothing") {
+        if (y.tag === "Nothing") { return Data$dOrdering.EQ; }
+        return Data$dOrdering.LT;
+      }
+      if (y.tag === "Nothing") { return Data$dOrdering.GT; }
+      if (x.tag === "Just" && y.tag === "Just") { return dictOrd.compare(x._1)(y._1); }
+      $runtime.fail();
+    },
+    Eq0: () => eqMaybe1
+  };
+};
+const ord1First = Data$dMaybe.ord1Maybe;
+const newtypeFirst = {Coercible0: () => {}};
+const monoidFirst = {mempty: Data$dMaybe.Nothing, Semigroup0: () => semigroupFirst};
+const monadFirst = Data$dMaybe.monadMaybe;
+const invariantFirst = Data$dMaybe.invariantMaybe;
+const functorFirst = Data$dMaybe.functorMaybe;
+const extendFirst = Data$dMaybe.extendMaybe;
+const eqFirst = dictEq => (
+  {
+    eq: x => y => {
+      if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+      return x.tag === "Just" && y.tag === "Just" && dictEq.eq(x._1)(y._1);
+    }
+  }
+);
+const eq1First = Data$dMaybe.eq1Maybe;
+const boundedFirst = dictBounded => Data$dMaybe.boundedMaybe(dictBounded);
+const bindFirst = Data$dMaybe.bindMaybe;
+const applyFirst = Data$dMaybe.applyMaybe;
+const applicativeFirst = Data$dMaybe.applicativeMaybe;
+const altFirst = /* #__PURE__ */ (() => ({alt: semigroupFirst.append, Functor0: () => Data$dMaybe.functorMaybe}))();
+const plusFirst = {empty: Data$dMaybe.Nothing, Alt0: () => altFirst};
+const alternativeFirst = {Applicative0: () => Data$dMaybe.applicativeMaybe, Plus1: () => plusFirst};
+export {
+  First,
+  altFirst,
+  alternativeFirst,
+  applicativeFirst,
+  applyFirst,
+  bindFirst,
+  boundedFirst,
+  eq1First,
+  eqFirst,
+  extendFirst,
+  functorFirst,
+  invariantFirst,
+  monadFirst,
+  monoidFirst,
+  newtypeFirst,
+  ord1First,
+  ordFirst,
+  plusFirst,
+  semigroupFirst,
+  showFirst
+};

package/output-es/Data.Maybe.Last/index.js

@@ -0,0 +1,86 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const Last = x => x;
+const showLast = dictShow => (
+  {
+    show: v => {
+      if (v.tag === "Just") { return "(Last (Just " + dictShow.show(v._1) + "))"; }
+      if (v.tag === "Nothing") { return "(Last Nothing)"; }
+      $runtime.fail();
+    }
+  }
+);
+const semigroupLast = {
+  append: v => v1 => {
+    if (v1.tag === "Just") { return v1; }
+    if (v1.tag === "Nothing") { return v; }
+    $runtime.fail();
+  }
+};
+const ordLast = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  const eqMaybe1 = {
+    eq: x => y => {
+      if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+      return x.tag === "Just" && y.tag === "Just" && $0.eq(x._1)(y._1);
+    }
+  };
+  return {
+    compare: x => y => {
+      if (x.tag === "Nothing") {
+        if (y.tag === "Nothing") { return Data$dOrdering.EQ; }
+        return Data$dOrdering.LT;
+      }
+      if (y.tag === "Nothing") { return Data$dOrdering.GT; }
+      if (x.tag === "Just" && y.tag === "Just") { return dictOrd.compare(x._1)(y._1); }
+      $runtime.fail();
+    },
+    Eq0: () => eqMaybe1
+  };
+};
+const ord1Last = Data$dMaybe.ord1Maybe;
+const newtypeLast = {Coercible0: () => {}};
+const monoidLast = {mempty: Data$dMaybe.Nothing, Semigroup0: () => semigroupLast};
+const monadLast = Data$dMaybe.monadMaybe;
+const invariantLast = Data$dMaybe.invariantMaybe;
+const functorLast = Data$dMaybe.functorMaybe;
+const extendLast = Data$dMaybe.extendMaybe;
+const eqLast = dictEq => (
+  {
+    eq: x => y => {
+      if (x.tag === "Nothing") { return y.tag === "Nothing"; }
+      return x.tag === "Just" && y.tag === "Just" && dictEq.eq(x._1)(y._1);
+    }
+  }
+);
+const eq1Last = Data$dMaybe.eq1Maybe;
+const boundedLast = dictBounded => Data$dMaybe.boundedMaybe(dictBounded);
+const bindLast = Data$dMaybe.bindMaybe;
+const applyLast = Data$dMaybe.applyMaybe;
+const applicativeLast = Data$dMaybe.applicativeMaybe;
+const altLast = /* #__PURE__ */ (() => ({alt: semigroupLast.append, Functor0: () => Data$dMaybe.functorMaybe}))();
+const plusLast = {empty: Data$dMaybe.Nothing, Alt0: () => altLast};
+const alternativeLast = {Applicative0: () => Data$dMaybe.applicativeMaybe, Plus1: () => plusLast};
+export {
+  Last,
+  altLast,
+  alternativeLast,
+  applicativeLast,
+  applyLast,
+  bindLast,
+  boundedLast,
+  eq1Last,
+  eqLast,
+  extendLast,
+  functorLast,
+  invariantLast,
+  monadLast,
+  monoidLast,
+  newtypeLast,
+  ord1Last,
+  ordLast,
+  plusLast,
+  semigroupLast,
+  showLast
+};

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

@@ -0,0 +1,8 @@
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+const MediaType = x => x;
+const showMediaType = {show: v => "(MediaType " + Data$dShow.showStringImpl(v) + ")"};
+const newtypeMediaType = {Coercible0: () => {}};
+const eqMediaType = {eq: x => y => x === y};
+const ordMediaType = {compare: x => y => Data$dOrd.ordString.compare(x)(y), Eq0: () => eqMediaType};
+export {MediaType, eqMediaType, newtypeMediaType, ordMediaType, showMediaType};

package/output-es/Data.MediaType.Common/index.js

@@ -0,0 +1,30 @@
+const textXML = "text/xml";
+const textPlain = "text/plain";
+const textHTML = "text/html";
+const textCSV = "text/csv";
+const textCSS = "text/css";
+const multipartFormData = "multipart/form-data";
+const imagePNG = "image/png";
+const imageJPEG = "image/jpeg";
+const imageGIF = "image/gif";
+const applicationXML = "application/xml";
+const applicationOctetStream = "application/octet-stream";
+const applicationJavascript = "application/javascript";
+const applicationJSON = "application/json";
+const applicationFormURLEncoded = "application/x-www-form-urlencoded";
+export {
+  applicationFormURLEncoded,
+  applicationJSON,
+  applicationJavascript,
+  applicationOctetStream,
+  applicationXML,
+  imageGIF,
+  imageJPEG,
+  imagePNG,
+  multipartFormData,
+  textCSS,
+  textCSV,
+  textHTML,
+  textPlain,
+  textXML
+};

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

@@ -0,0 +1,66 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEuclideanRing from "../Data.EuclideanRing/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Data$dSemigroup from "../Data.Semigroup/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+const monoidUnit = {mempty: undefined, Semigroup0: () => Data$dSemigroup.semigroupUnit};
+const monoidString = {mempty: "", Semigroup0: () => Data$dSemigroup.semigroupString};
+const monoidRecordNil = {memptyRecord: v => ({}), SemigroupRecord0: () => Data$dSemigroup.semigroupRecordNil};
+const monoidOrdering = {mempty: Data$dOrdering.EQ, Semigroup0: () => Data$dOrdering.semigroupOrdering};
+const monoidArray = {mempty: [], Semigroup0: () => Data$dSemigroup.semigroupArray};
+const memptyRecord = dict => dict.memptyRecord;
+const monoidRecord = () => dictMonoidRecord => {
+  const semigroupRecord1 = {append: dictMonoidRecord.SemigroupRecord0().appendRecord(Type$dProxy.Proxy)};
+  return {mempty: dictMonoidRecord.memptyRecord(Type$dProxy.Proxy), Semigroup0: () => semigroupRecord1};
+};
+const mempty = dict => dict.mempty;
+const monoidFn = dictMonoid => {
+  const mempty1 = dictMonoid.mempty;
+  const $0 = dictMonoid.Semigroup0();
+  const semigroupFn = {append: f => g => x => $0.append(f(x))(g(x))};
+  return {mempty: v => mempty1, Semigroup0: () => semigroupFn};
+};
+const monoidRecordCons = dictIsSymbol => dictMonoid => {
+  const mempty1 = dictMonoid.mempty;
+  const Semigroup0 = dictMonoid.Semigroup0();
+  return () => dictMonoidRecord => {
+    const $0 = dictMonoidRecord.SemigroupRecord0();
+    const semigroupRecordCons1 = {
+      appendRecord: v => ra => rb => {
+        const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+        const $$get = Record$dUnsafe.unsafeGet(key);
+        return Record$dUnsafe.unsafeSet(key)(Semigroup0.append($$get(ra))($$get(rb)))($0.appendRecord(Type$dProxy.Proxy)(ra)(rb));
+      }
+    };
+    return {
+      memptyRecord: v => Record$dUnsafe.unsafeSet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy))(mempty1)(dictMonoidRecord.memptyRecord(Type$dProxy.Proxy)),
+      SemigroupRecord0: () => semigroupRecordCons1
+    };
+  };
+};
+const power = dictMonoid => {
+  const mempty1 = dictMonoid.mempty;
+  const $0 = dictMonoid.Semigroup0();
+  return x => {
+    const go = p => {
+      if (p <= 0) { return mempty1; }
+      if (p === 1) { return x; }
+      if (Data$dEuclideanRing.intMod(p)(2) === 0) {
+        const x$p = go($runtime.intDiv(p, 2));
+        return $0.append(x$p)(x$p);
+      }
+      const x$p = go($runtime.intDiv(p, 2));
+      return $0.append(x$p)($0.append(x$p)(x));
+    };
+    return go;
+  };
+};
+const guard = dictMonoid => {
+  const mempty1 = dictMonoid.mempty;
+  return v => v1 => {
+    if (v) { return v1; }
+    return mempty1;
+  };
+};
+export {guard, mempty, memptyRecord, monoidArray, monoidFn, monoidOrdering, monoidRecord, monoidRecordCons, monoidRecordNil, monoidString, monoidUnit, power};

package/output-es/Data.Monoid.Additive/index.js

@@ -0,0 +1,33 @@
+const Additive = x => x;
+const showAdditive = dictShow => ({show: v => "(Additive " + dictShow.show(v) + ")"});
+const semigroupAdditive = dictSemiring => ({append: v => v1 => dictSemiring.add(v)(v1)});
+const ordAdditive = dictOrd => dictOrd;
+const monoidAdditive = dictSemiring => {
+  const semigroupAdditive1 = {append: v => v1 => dictSemiring.add(v)(v1)};
+  return {mempty: dictSemiring.zero, Semigroup0: () => semigroupAdditive1};
+};
+const functorAdditive = {map: f => m => f(m)};
+const eqAdditive = dictEq => dictEq;
+const eq1Additive = {eq1: dictEq => dictEq.eq};
+const ord1Additive = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Additive};
+const boundedAdditive = dictBounded => dictBounded;
+const applyAdditive = {apply: v => v1 => v(v1), Functor0: () => functorAdditive};
+const bindAdditive = {bind: v => f => f(v), Apply0: () => applyAdditive};
+const applicativeAdditive = {pure: Additive, Apply0: () => applyAdditive};
+const monadAdditive = {Applicative0: () => applicativeAdditive, Bind1: () => bindAdditive};
+export {
+  Additive,
+  applicativeAdditive,
+  applyAdditive,
+  bindAdditive,
+  boundedAdditive,
+  eq1Additive,
+  eqAdditive,
+  functorAdditive,
+  monadAdditive,
+  monoidAdditive,
+  ord1Additive,
+  ordAdditive,
+  semigroupAdditive,
+  showAdditive
+};

package/output-es/Data.Monoid.Alternate/index.js

@@ -0,0 +1,46 @@
+const Alternate = x => x;
+const showAlternate = dictShow => ({show: v => "(Alternate " + dictShow.show(v) + ")"});
+const semigroupAlternate = dictAlt => ({append: v => v1 => dictAlt.alt(v)(v1)});
+const plusAlternate = dictPlus => dictPlus;
+const ordAlternate = dictOrd => dictOrd;
+const ord1Alternate = dictOrd1 => dictOrd1;
+const newtypeAlternate = {Coercible0: () => {}};
+const monoidAlternate = dictPlus => {
+  const $0 = dictPlus.Alt0();
+  const semigroupAlternate1 = {append: v => v1 => $0.alt(v)(v1)};
+  return {mempty: dictPlus.empty, Semigroup0: () => semigroupAlternate1};
+};
+const monadAlternate = dictMonad => dictMonad;
+const functorAlternate = dictFunctor => dictFunctor;
+const extendAlternate = dictExtend => dictExtend;
+const eqAlternate = dictEq => dictEq;
+const eq1Alternate = dictEq1 => dictEq1;
+const comonadAlternate = dictComonad => dictComonad;
+const boundedAlternate = dictBounded => dictBounded;
+const bindAlternate = dictBind => dictBind;
+const applyAlternate = dictApply => dictApply;
+const applicativeAlternate = dictApplicative => dictApplicative;
+const alternativeAlternate = dictAlternative => dictAlternative;
+const altAlternate = dictAlt => dictAlt;
+export {
+  Alternate,
+  altAlternate,
+  alternativeAlternate,
+  applicativeAlternate,
+  applyAlternate,
+  bindAlternate,
+  boundedAlternate,
+  comonadAlternate,
+  eq1Alternate,
+  eqAlternate,
+  extendAlternate,
+  functorAlternate,
+  monadAlternate,
+  monoidAlternate,
+  newtypeAlternate,
+  ord1Alternate,
+  ordAlternate,
+  plusAlternate,
+  semigroupAlternate,
+  showAlternate
+};

package/output-es/Data.Monoid.Conj/index.js

@@ -0,0 +1,21 @@
+const Conj = x => x;
+const showConj = dictShow => ({show: v => "(Conj " + dictShow.show(v) + ")"});
+const semiringConj = dictHeytingAlgebra => (
+  {zero: dictHeytingAlgebra.tt, one: dictHeytingAlgebra.ff, add: v => v1 => dictHeytingAlgebra.conj(v)(v1), mul: v => v1 => dictHeytingAlgebra.disj(v)(v1)}
+);
+const semigroupConj = dictHeytingAlgebra => ({append: v => v1 => dictHeytingAlgebra.conj(v)(v1)});
+const ordConj = dictOrd => dictOrd;
+const monoidConj = dictHeytingAlgebra => {
+  const semigroupConj1 = {append: v => v1 => dictHeytingAlgebra.conj(v)(v1)};
+  return {mempty: dictHeytingAlgebra.tt, Semigroup0: () => semigroupConj1};
+};
+const functorConj = {map: f => m => f(m)};
+const eqConj = dictEq => dictEq;
+const eq1Conj = {eq1: dictEq => dictEq.eq};
+const ord1Conj = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Conj};
+const boundedConj = dictBounded => dictBounded;
+const applyConj = {apply: v => v1 => v(v1), Functor0: () => functorConj};
+const bindConj = {bind: v => f => f(v), Apply0: () => applyConj};
+const applicativeConj = {pure: Conj, Apply0: () => applyConj};
+const monadConj = {Applicative0: () => applicativeConj, Bind1: () => bindConj};
+export {Conj, applicativeConj, applyConj, bindConj, boundedConj, eq1Conj, eqConj, functorConj, monadConj, monoidConj, ord1Conj, ordConj, semigroupConj, semiringConj, showConj};

package/output-es/Data.Monoid.Disj/index.js

@@ -0,0 +1,21 @@
+const Disj = x => x;
+const showDisj = dictShow => ({show: v => "(Disj " + dictShow.show(v) + ")"});
+const semiringDisj = dictHeytingAlgebra => (
+  {zero: dictHeytingAlgebra.ff, one: dictHeytingAlgebra.tt, add: v => v1 => dictHeytingAlgebra.disj(v)(v1), mul: v => v1 => dictHeytingAlgebra.conj(v)(v1)}
+);
+const semigroupDisj = dictHeytingAlgebra => ({append: v => v1 => dictHeytingAlgebra.disj(v)(v1)});
+const ordDisj = dictOrd => dictOrd;
+const monoidDisj = dictHeytingAlgebra => {
+  const semigroupDisj1 = {append: v => v1 => dictHeytingAlgebra.disj(v)(v1)};
+  return {mempty: dictHeytingAlgebra.ff, Semigroup0: () => semigroupDisj1};
+};
+const functorDisj = {map: f => m => f(m)};
+const eqDisj = dictEq => dictEq;
+const eq1Disj = {eq1: dictEq => dictEq.eq};
+const ord1Disj = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Disj};
+const boundedDisj = dictBounded => dictBounded;
+const applyDisj = {apply: v => v1 => v(v1), Functor0: () => functorDisj};
+const bindDisj = {bind: v => f => f(v), Apply0: () => applyDisj};
+const applicativeDisj = {pure: Disj, Apply0: () => applyDisj};
+const monadDisj = {Applicative0: () => applicativeDisj, Bind1: () => bindDisj};
+export {Disj, applicativeDisj, applyDisj, bindDisj, boundedDisj, eq1Disj, eqDisj, functorDisj, monadDisj, monoidDisj, ord1Disj, ordDisj, semigroupDisj, semiringDisj, showDisj};

package/output-es/Data.Monoid.Dual/index.js

@@ -0,0 +1,19 @@
+const Dual = x => x;
+const showDual = dictShow => ({show: v => "(Dual " + dictShow.show(v) + ")"});
+const semigroupDual = dictSemigroup => ({append: v => v1 => dictSemigroup.append(v1)(v)});
+const ordDual = dictOrd => dictOrd;
+const monoidDual = dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const semigroupDual1 = {append: v => v1 => $0.append(v1)(v)};
+  return {mempty: dictMonoid.mempty, Semigroup0: () => semigroupDual1};
+};
+const functorDual = {map: f => m => f(m)};
+const eqDual = dictEq => dictEq;
+const eq1Dual = {eq1: dictEq => dictEq.eq};
+const ord1Dual = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Dual};
+const boundedDual = dictBounded => dictBounded;
+const applyDual = {apply: v => v1 => v(v1), Functor0: () => functorDual};
+const bindDual = {bind: v => f => f(v), Apply0: () => applyDual};
+const applicativeDual = {pure: Dual, Apply0: () => applyDual};
+const monadDual = {Applicative0: () => applicativeDual, Bind1: () => bindDual};
+export {Dual, applicativeDual, applyDual, bindDual, boundedDual, eq1Dual, eqDual, functorDual, monadDual, monoidDual, ord1Dual, ordDual, semigroupDual, showDual};