@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Control.Monad.Writer.Trans/index.js

@@ -0,0 +1,256 @@
+// | This module defines the writer monad transformer, `WriterT`.
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const WriterT = x => x;
+const runWriterT = v => v;
+const newtypeWriterT = {Coercible0: () => {}};
+const monadTransWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return {lift: dictMonad => m => dictMonad.Bind1().bind(m)(a => dictMonad.Applicative0().pure(Data$dTuple.$Tuple(a, mempty)))};
+};
+const mapWriterT = f => v => f(v);
+const functorWriterT = dictFunctor => ({map: f => dictFunctor.map(v => Data$dTuple.$Tuple(f(v._1), v._2))});
+const execWriterT = dictFunctor => v => dictFunctor.map(Data$dTuple.snd)(v);
+const applyWriterT = dictSemigroup => dictApply => {
+  const Functor0 = dictApply.Functor0();
+  const functorWriterT1 = {map: f => Functor0.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+  return {apply: v => v1 => dictApply.apply(Functor0.map(v3 => v4 => Data$dTuple.$Tuple(v3._1(v4._1), dictSemigroup.append(v3._2)(v4._2)))(v))(v1), Functor0: () => functorWriterT1};
+};
+const bindWriterT = dictSemigroup => dictBind => {
+  const Apply0 = dictBind.Apply0();
+  const Functor0 = Apply0.Functor0();
+  const functorWriterT1 = {map: f => Functor0.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+  const applyWriterT2 = {
+    apply: v => v1 => Apply0.apply(Functor0.map(v3 => v4 => Data$dTuple.$Tuple(v3._1(v4._1), dictSemigroup.append(v3._2)(v4._2)))(v))(v1),
+    Functor0: () => functorWriterT1
+  };
+  return {
+    bind: v => k => dictBind.bind(v)(v1 => {
+      const $0 = v1._2;
+      return Apply0.Functor0().map(v3 => Data$dTuple.$Tuple(v3._1, dictSemigroup.append($0)(v3._2)))(k(v1._1));
+    }),
+    Apply0: () => applyWriterT2
+  };
+};
+const semigroupWriterT = dictApply => dictSemigroup => {
+  const Functor0 = dictApply.Functor0();
+  return dictSemigroup1 => (
+    {
+      append: a => b => dictApply.apply(Functor0.map(v3 => v4 => Data$dTuple.$Tuple(v3._1(v4._1), dictSemigroup.append(v3._2)(v4._2)))(Functor0.map(v => Data$dTuple.$Tuple(
+        dictSemigroup1.append(v._1),
+        v._2
+      ))(a)))(b)
+    }
+  );
+};
+const applicativeWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const $0 = dictMonoid.Semigroup0();
+  return dictApplicative => {
+    const $1 = dictApplicative.Apply0();
+    const Functor0 = $1.Functor0();
+    const applyWriterT2 = (() => {
+      const functorWriterT1 = {map: f => Functor0.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+      return {apply: v => v1 => $1.apply(Functor0.map(v3 => v4 => Data$dTuple.$Tuple(v3._1(v4._1), $0.append(v3._2)(v4._2)))(v))(v1), Functor0: () => functorWriterT1};
+    })();
+    return {pure: a => dictApplicative.pure(Data$dTuple.$Tuple(a, mempty)), Apply0: () => applyWriterT2};
+  };
+};
+const monadWriterT = dictMonoid => {
+  const applicativeWriterT1 = applicativeWriterT(dictMonoid);
+  const bindWriterT1 = bindWriterT(dictMonoid.Semigroup0());
+  return dictMonad => {
+    const applicativeWriterT2 = applicativeWriterT1(dictMonad.Applicative0());
+    const bindWriterT2 = bindWriterT1(dictMonad.Bind1());
+    return {Applicative0: () => applicativeWriterT2, Bind1: () => bindWriterT2};
+  };
+};
+const monadAskWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonadAsk => {
+    const Monad0 = dictMonadAsk.Monad0();
+    const monadWriterT2 = monadWriterT1(Monad0);
+    return {ask: Monad0.Bind1().bind(dictMonadAsk.ask)(a => Monad0.Applicative0().pure(Data$dTuple.$Tuple(a, mempty))), Monad0: () => monadWriterT2};
+  };
+};
+const monadReaderWriterT = dictMonoid => {
+  const monadAskWriterT1 = monadAskWriterT(dictMonoid);
+  return dictMonadReader => {
+    const monadAskWriterT2 = monadAskWriterT1(dictMonadReader.MonadAsk0());
+    return {local: f => dictMonadReader.local(f), MonadAsk0: () => monadAskWriterT2};
+  };
+};
+const monadContWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonadCont => {
+    const monadWriterT2 = monadWriterT1(dictMonadCont.Monad0());
+    return {callCC: f => dictMonadCont.callCC(c => f(a => c(Data$dTuple.$Tuple(a, mempty)))), Monad0: () => monadWriterT2};
+  };
+};
+const monadEffectWriter = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonadEffect => {
+    const Monad0 = dictMonadEffect.Monad0();
+    const monadWriterT2 = monadWriterT1(Monad0);
+    return {liftEffect: x => Monad0.Bind1().bind(dictMonadEffect.liftEffect(x))(a => Monad0.Applicative0().pure(Data$dTuple.$Tuple(a, mempty))), Monad0: () => monadWriterT2};
+  };
+};
+const monadRecWriterT = dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const mempty = dictMonoid.mempty;
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonadRec => {
+    const Monad0 = dictMonadRec.Monad0();
+    const monadWriterT2 = monadWriterT1(Monad0);
+    return {
+      tailRecM: f => a => dictMonadRec.tailRecM(v => {
+        const $1 = v._2;
+        return Monad0.Bind1().bind(f(v._1))(v2 => Monad0.Applicative0().pure((() => {
+          if (v2._1.tag === "Loop") { return Control$dMonad$dRec$dClass.$Step("Loop", Data$dTuple.$Tuple(v2._1._1, $0.append($1)(v2._2))); }
+          if (v2._1.tag === "Done") { return Control$dMonad$dRec$dClass.$Step("Done", Data$dTuple.$Tuple(v2._1._1, $0.append($1)(v2._2))); }
+          $runtime.fail();
+        })()));
+      })(Data$dTuple.$Tuple(a, mempty)),
+      Monad0: () => monadWriterT2
+    };
+  };
+};
+const monadStateWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonadState => {
+    const Monad0 = dictMonadState.Monad0();
+    const monadWriterT2 = monadWriterT1(Monad0);
+    return {state: f => Monad0.Bind1().bind(dictMonadState.state(f))(a => Monad0.Applicative0().pure(Data$dTuple.$Tuple(a, mempty))), Monad0: () => monadWriterT2};
+  };
+};
+const monadTellWriterT = dictMonoid => {
+  const Semigroup0 = dictMonoid.Semigroup0();
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonad => {
+    const monadWriterT2 = monadWriterT1(dictMonad);
+    return {
+      tell: (() => {
+        const $0 = Data$dTuple.Tuple();
+        return x => dictMonad.Applicative0().pure($0(x));
+      })(),
+      Semigroup0: () => Semigroup0,
+      Monad1: () => monadWriterT2
+    };
+  };
+};
+const monadWriterWriterT = dictMonoid => {
+  const monadTellWriterT1 = monadTellWriterT(dictMonoid);
+  return dictMonad => {
+    const $0 = dictMonad.Bind1();
+    const $1 = dictMonad.Applicative0();
+    const monadTellWriterT2 = monadTellWriterT1(dictMonad);
+    return {
+      listen: v => $0.bind(v)(v1 => $1.pure(Data$dTuple.$Tuple(Data$dTuple.$Tuple(v1._1, v1._2), v1._2))),
+      pass: v => $0.bind(v)(v1 => $1.pure(Data$dTuple.$Tuple(v1._1._1, v1._1._2(v1._2)))),
+      Monoid0: () => dictMonoid,
+      MonadTell1: () => monadTellWriterT2
+    };
+  };
+};
+const monadThrowWriterT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  return dictMonadThrow => {
+    const Monad0 = dictMonadThrow.Monad0();
+    const monadWriterT2 = monadWriterT1(Monad0);
+    return {throwError: e => Monad0.Bind1().bind(dictMonadThrow.throwError(e))(a => Monad0.Applicative0().pure(Data$dTuple.$Tuple(a, mempty))), Monad0: () => monadWriterT2};
+  };
+};
+const monadErrorWriterT = dictMonoid => {
+  const monadThrowWriterT1 = monadThrowWriterT(dictMonoid);
+  return dictMonadError => {
+    const monadThrowWriterT2 = monadThrowWriterT1(dictMonadError.MonadThrow0());
+    return {catchError: v => h => dictMonadError.catchError(v)(e => h(e)), MonadThrow0: () => monadThrowWriterT2};
+  };
+};
+const monoidWriterT = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  return dictMonoid => {
+    const $1 = dictMonoid.Semigroup0();
+    const Functor0 = $0.Functor0();
+    return dictMonoid1 => {
+      const $2 = dictMonoid1.Semigroup0();
+      const semigroupWriterT3 = {
+        append: a => b => $0.apply(Functor0.map(v3 => v4 => Data$dTuple.$Tuple(v3._1(v4._1), $1.append(v3._2)(v4._2)))(Functor0.map(v => Data$dTuple.$Tuple($2.append(v._1), v._2))(a)))(b)
+      };
+      return {mempty: applicativeWriterT(dictMonoid)(dictApplicative).pure(dictMonoid1.mempty), Semigroup0: () => semigroupWriterT3};
+    };
+  };
+};
+const altWriterT = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  const functorWriterT1 = {map: f => $0.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+  return {alt: v => v1 => dictAlt.alt(v)(v1), Functor0: () => functorWriterT1};
+};
+const plusWriterT = dictPlus => {
+  const $0 = dictPlus.Alt0();
+  const $1 = $0.Functor0();
+  const altWriterT1 = (() => {
+    const functorWriterT1 = {map: f => $1.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+    return {alt: v => v1 => $0.alt(v)(v1), Functor0: () => functorWriterT1};
+  })();
+  return {empty: dictPlus.empty, Alt0: () => altWriterT1};
+};
+const alternativeWriterT = dictMonoid => {
+  const applicativeWriterT1 = applicativeWriterT(dictMonoid);
+  return dictAlternative => {
+    const applicativeWriterT2 = applicativeWriterT1(dictAlternative.Applicative0());
+    const $0 = dictAlternative.Plus1();
+    const $1 = $0.Alt0();
+    const plusWriterT1 = (() => {
+      const $2 = $1.Functor0();
+      const functorWriterT1 = {map: f => $2.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+      const altWriterT1 = {alt: v => v1 => $1.alt(v)(v1), Functor0: () => functorWriterT1};
+      return {empty: $0.empty, Alt0: () => altWriterT1};
+    })();
+    return {Applicative0: () => applicativeWriterT2, Plus1: () => plusWriterT1};
+  };
+};
+const monadPlusWriterT = dictMonoid => {
+  const monadWriterT1 = monadWriterT(dictMonoid);
+  const alternativeWriterT1 = alternativeWriterT(dictMonoid);
+  return dictMonadPlus => {
+    const monadWriterT2 = monadWriterT1(dictMonadPlus.Monad0());
+    const alternativeWriterT2 = alternativeWriterT1(dictMonadPlus.Alternative1());
+    return {Monad0: () => monadWriterT2, Alternative1: () => alternativeWriterT2};
+  };
+};
+export {
+  WriterT,
+  altWriterT,
+  alternativeWriterT,
+  applicativeWriterT,
+  applyWriterT,
+  bindWriterT,
+  execWriterT,
+  functorWriterT,
+  mapWriterT,
+  monadAskWriterT,
+  monadContWriterT,
+  monadEffectWriter,
+  monadErrorWriterT,
+  monadPlusWriterT,
+  monadReaderWriterT,
+  monadRecWriterT,
+  monadStateWriterT,
+  monadTellWriterT,
+  monadThrowWriterT,
+  monadTransWriterT,
+  monadWriterT,
+  monadWriterWriterT,
+  monoidWriterT,
+  newtypeWriterT,
+  plusWriterT,
+  runWriterT,
+  semigroupWriterT
+};

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

@@ -0,0 +1,4 @@
+import * as Control$dAlternative from "../Control.Alternative/index.js";
+import * as Control$dMonad from "../Control.Monad/index.js";
+const monadPlusArray = {Monad0: () => Control$dMonad.monadArray, Alternative1: () => Control$dAlternative.alternativeArray};
+export {monadPlusArray};

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

@@ -0,0 +1,49 @@
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+const identity = x => x;
+const parTraverse_ = dictParallel => dictApplicative => {
+  const traverse_ = Data$dFoldable.traverse_(dictApplicative);
+  return dictFoldable => {
+    const traverse_1 = traverse_(dictFoldable);
+    return f => {
+      const $0 = traverse_1(x => dictParallel.parallel(f(x)));
+      return x => dictParallel.sequential($0(x));
+    };
+  };
+};
+const parTraverse = dictParallel => dictApplicative => dictTraversable => {
+  const traverse = dictTraversable.traverse(dictApplicative);
+  return f => {
+    const $0 = traverse(x => dictParallel.parallel(f(x)));
+    return x => dictParallel.sequential($0(x));
+  };
+};
+const parSequence_ = dictParallel => dictApplicative => {
+  const parTraverse_2 = parTraverse_(dictParallel)(dictApplicative);
+  return dictFoldable => parTraverse_2(dictFoldable)(identity);
+};
+const parSequence = dictParallel => dictApplicative => dictTraversable => {
+  const $0 = dictTraversable.traverse(dictApplicative)(x => dictParallel.parallel(x));
+  return x => dictParallel.sequential($0(x));
+};
+const parOneOfMap = dictParallel => dictAlternative => {
+  const Plus1 = dictAlternative.Plus1();
+  return dictFoldable => {
+    const empty = Plus1.empty;
+    return dictFunctor => f => {
+      const $0 = dictFoldable.foldr(x => Plus1.Alt0().alt(dictParallel.parallel(f(x))))(empty);
+      return x => dictParallel.sequential($0(x));
+    };
+  };
+};
+const parOneOf = dictParallel => dictAlternative => {
+  const Plus1 = dictAlternative.Plus1();
+  return dictFoldable => {
+    const empty = Plus1.empty;
+    return dictFunctor => {
+      const $0 = dictFoldable.foldr(x => Plus1.Alt0().alt(dictParallel.parallel(x)))(empty);
+      return x => dictParallel.sequential($0(x));
+    };
+  };
+};
+const parApply = dictParallel => mf => ma => dictParallel.sequential(dictParallel.Apply1().apply(dictParallel.parallel(mf))(dictParallel.parallel(ma)));
+export {identity, parApply, parOneOf, parOneOfMap, parSequence, parSequence_, parTraverse, parTraverse_};

package/output-es/Control.Parallel.Class/index.js

@@ -0,0 +1,191 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Control$dMonad$dMaybe$dTrans from "../Control.Monad.Maybe.Trans/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFunctor$dCostar from "../Data.Functor.Costar/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const ParCont = x => x;
+const sequential = dict => dict.sequential;
+const parallel = dict => dict.parallel;
+const newtypeParCont = {Coercible0: () => {}};
+const monadParWriterT = dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const applyWriterT = dictApply => {
+    const Functor0 = dictApply.Functor0();
+    const functorWriterT1 = {map: f => Functor0.map(v => Data$dTuple.$Tuple(f(v._1), v._2))};
+    return {apply: v => v1 => dictApply.apply(Functor0.map(v3 => v4 => Data$dTuple.$Tuple(v3._1(v4._1), $0.append(v3._2)(v4._2)))(v))(v1), Functor0: () => functorWriterT1};
+  };
+  return dictParallel => {
+    const applyWriterT1 = applyWriterT(dictParallel.Apply0());
+    const applyWriterT2 = applyWriterT(dictParallel.Apply1());
+    return {parallel: v => dictParallel.parallel(v), sequential: v => dictParallel.sequential(v), Apply0: () => applyWriterT1, Apply1: () => applyWriterT2};
+  };
+};
+const monadParStar = dictParallel => {
+  const $0 = dictParallel.Apply0();
+  const $1 = $0.Functor0();
+  const applyStar = (() => {
+    const functorStar1 = {
+      map: f => v => {
+        const $2 = $1.map(f);
+        return x => $2(v(x));
+      }
+    };
+    return {apply: v => v1 => a => $0.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+  })();
+  const $2 = dictParallel.Apply1();
+  const $3 = $2.Functor0();
+  const applyStar1 = (() => {
+    const functorStar1 = {
+      map: f => v => {
+        const $4 = $3.map(f);
+        return x => $4(v(x));
+      }
+    };
+    return {apply: v => v1 => a => $2.apply(v(a))(v1(a)), Functor0: () => functorStar1};
+  })();
+  return {parallel: v => x => dictParallel.parallel(v(x)), sequential: v => x => dictParallel.sequential(v(x)), Apply0: () => applyStar, Apply1: () => applyStar1};
+};
+const monadParReaderT = dictParallel => {
+  const $0 = dictParallel.Apply0();
+  const $1 = $0.Functor0();
+  const applyReaderT = (() => {
+    const functorReaderT1 = {
+      map: x => {
+        const $2 = $1.map(x);
+        return v => x$1 => $2(v(x$1));
+      }
+    };
+    return {apply: v => v1 => r => $0.apply(v(r))(v1(r)), Functor0: () => functorReaderT1};
+  })();
+  const $2 = dictParallel.Apply1();
+  const $3 = $2.Functor0();
+  const applyReaderT1 = (() => {
+    const functorReaderT1 = {
+      map: x => {
+        const $4 = $3.map(x);
+        return v => x$1 => $4(v(x$1));
+      }
+    };
+    return {apply: v => v1 => r => $2.apply(v(r))(v1(r)), Functor0: () => functorReaderT1};
+  })();
+  return {parallel: v => x => dictParallel.parallel(v(x)), sequential: v => x => dictParallel.sequential(v(x)), Apply0: () => applyReaderT, Apply1: () => applyReaderT1};
+};
+const monadParMaybeT = dictParallel => {
+  const $0 = dictParallel.Apply1();
+  const Functor0 = $0.Functor0();
+  const functorCompose2 = {
+    map: f => v => Functor0.map(v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", f(v1._1)); }
+      return Data$dMaybe.Nothing;
+    })(v)
+  };
+  const applyCompose = {apply: v => v1 => $0.apply(Functor0.map(Data$dMaybe.applyMaybe.apply)(v))(v1), Functor0: () => functorCompose2};
+  return dictMonad => {
+    const applyMaybeT = Control$dMonad$dMaybe$dTrans.applyMaybeT(dictMonad);
+    return {parallel: v => dictParallel.parallel(v), sequential: v => dictParallel.sequential(v), Apply0: () => applyMaybeT, Apply1: () => applyCompose};
+  };
+};
+const monadParExceptT = dictParallel => {
+  const $0 = dictParallel.Apply1();
+  const Functor0 = $0.Functor0();
+  const functorCompose2 = {
+    map: f => v => Functor0.map(m => {
+      if (m.tag === "Left") { return Data$dEither.$Either("Left", m._1); }
+      if (m.tag === "Right") { return Data$dEither.$Either("Right", f(m._1)); }
+      $runtime.fail();
+    })(v)
+  };
+  const applyCompose = {apply: v => v1 => $0.apply(Functor0.map(Data$dEither.applyEither.apply)(v))(v1), Functor0: () => functorCompose2};
+  return dictMonad => {
+    const applyExceptT = Control$dMonad$dExcept$dTrans.applyExceptT(dictMonad);
+    return {parallel: v => dictParallel.parallel(v), sequential: v => dictParallel.sequential(v), Apply0: () => applyExceptT, Apply1: () => applyCompose};
+  };
+};
+const monadParCostar = dictParallel => (
+  {
+    parallel: v => x => v(dictParallel.sequential(x)),
+    sequential: v => x => v(dictParallel.parallel(x)),
+    Apply0: () => Data$dFunctor$dCostar.applyCostar,
+    Apply1: () => Data$dFunctor$dCostar.applyCostar
+  }
+);
+const monadParParCont = dictMonadEffect => {
+  const functorContT1 = {map: f => v => k => v(a => k(f(a)))};
+  const applyContT = {apply: v => v1 => k => v(g => v1(a => k(g(a)))), Functor0: () => functorContT1};
+  return {parallel: ParCont, sequential: v => v, Apply0: () => applyContT, Apply1: () => applyParCont(dictMonadEffect)};
+};
+const functorParCont = dictMonadEffect => (
+  {
+    map: f => x => monadParParCont(dictMonadEffect).parallel((() => {
+      const $0 = monadParParCont(dictMonadEffect).sequential(x);
+      return k => $0(a => k(f(a)));
+    })())
+  }
+);
+const applyParCont = dictMonadEffect => {
+  const Bind1 = dictMonadEffect.Monad0().Bind1();
+  return {
+    apply: v => v1 => k => Bind1.bind(dictMonadEffect.liftEffect(() => ({value: Data$dMaybe.Nothing})))(ra => Bind1.bind(dictMonadEffect.liftEffect(() => (
+      {value: Data$dMaybe.Nothing}
+    )))(rb => Bind1.bind(v(a => Bind1.bind(dictMonadEffect.liftEffect(() => rb.value))(mb => {
+      if (mb.tag === "Nothing") { return dictMonadEffect.liftEffect(() => ra.value = Data$dMaybe.$Maybe("Just", a)); }
+      if (mb.tag === "Just") { return k(a(mb._1)); }
+      $runtime.fail();
+    })))(() => v1(b => Bind1.bind(dictMonadEffect.liftEffect(() => ra.value))(ma => {
+      if (ma.tag === "Nothing") { return dictMonadEffect.liftEffect(() => rb.value = Data$dMaybe.$Maybe("Just", b)); }
+      if (ma.tag === "Just") { return k(ma._1(b)); }
+      $runtime.fail();
+    }))))),
+    Functor0: () => functorParCont(dictMonadEffect)
+  };
+};
+const applicativeParCont = dictMonadEffect => {
+  const applyParCont1 = applyParCont(dictMonadEffect);
+  return {pure: x => monadParParCont(dictMonadEffect).parallel(k => k(x)), Apply0: () => applyParCont1};
+};
+const altParCont = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const $0 = Monad0.Applicative0();
+  const functorParCont1 = functorParCont(dictMonadEffect);
+  return {
+    alt: v => v1 => k => Bind1.bind(dictMonadEffect.liftEffect(() => ({value: false})))(done => Bind1.bind(v(a => Bind1.bind(dictMonadEffect.liftEffect(() => done.value))(b => {
+      if (b) { return $0.pure(); }
+      return Bind1.bind(dictMonadEffect.liftEffect(() => done.value = true))(() => k(a));
+    })))(() => v1(a => Bind1.bind(dictMonadEffect.liftEffect(() => done.value))(b => {
+      if (b) { return $0.pure(); }
+      return Bind1.bind(dictMonadEffect.liftEffect(() => done.value = true))(() => k(a));
+    })))),
+    Functor0: () => functorParCont1
+  };
+};
+const plusParCont = dictMonadEffect => {
+  const altParCont1 = altParCont(dictMonadEffect);
+  return {empty: v => dictMonadEffect.Monad0().Applicative0().pure(), Alt0: () => altParCont1};
+};
+const alternativeParCont = dictMonadEffect => {
+  const applicativeParCont1 = applicativeParCont(dictMonadEffect);
+  const plusParCont1 = plusParCont(dictMonadEffect);
+  return {Applicative0: () => applicativeParCont1, Plus1: () => plusParCont1};
+};
+export {
+  ParCont,
+  altParCont,
+  alternativeParCont,
+  applicativeParCont,
+  applyParCont,
+  functorParCont,
+  monadParCostar,
+  monadParExceptT,
+  monadParMaybeT,
+  monadParParCont,
+  monadParReaderT,
+  monadParStar,
+  monadParWriterT,
+  newtypeParCont,
+  parallel,
+  plusParCont,
+  sequential
+};

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

@@ -0,0 +1,4 @@
+import * as Control$dAlt from "../Control.Alt/index.js";
+const plusArray = {empty: [], Alt0: () => Control$dAlt.altArray};
+const empty = dict => dict.empty;
+export {empty, plusArray};

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

@@ -0,0 +1,24 @@
+export function promise(f) {
+  return function () {
+    return new Promise(function (success, error) {
+      var succF = function (s) { return function() { return success(s); } };
+      var failF = function (s) { return function() { return error(s); } };
+
+      // This indicates the aff was wrong?
+      try { f(succF)(failF)(); }
+      catch (e) {
+        error(e);
+      }
+    });
+  };
+}
+
+export function thenImpl(promise) {
+  return function(errCB) {
+    return function(succCB) {
+      return function() {
+        promise.then(succCB, errCB);
+      };
+    };
+  };
+}

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

@@ -0,0 +1,40 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Effect$dAff from "../Effect.Aff/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Foreign from "../Foreign/index.js";
+import {promise, thenImpl} from "./foreign.js";
+const alt = /* #__PURE__ */ (() => Control$dMonad$dExcept$dTrans.altExceptT(Data$dList$dTypes.semigroupNonEmptyList)(Data$dIdentity.monadIdentity).alt)();
+const toAff$p = customCoerce => p => Effect$dAff.makeAff(cb => {
+  const $0 = thenImpl(p)($0 => cb(Data$dEither.$Either("Left", customCoerce($0)))())(x => cb(Data$dEither.$Either("Right", x))());
+  return () => {
+    $0();
+    return Effect$dAff.nonCanceler;
+  };
+});
+const fromAff = aff => promise(succ => err => {
+  const $0 = Effect$dAff.runAff(v2 => {
+    if (v2.tag === "Left") { return err(v2._1); }
+    if (v2.tag === "Right") { return succ(v2._1); }
+    $runtime.fail();
+  })(aff);
+  return () => {$0();};
+});
+const coerce = fn => {
+  const $0 = alt(Foreign.unsafeReadTagged(Data$dIdentity.monadIdentity)("Error")(fn))((() => {
+    const $0 = Foreign.unsafeReadTagged(Data$dIdentity.monadIdentity)("String")(fn);
+    if ($0.tag === "Left") { return Data$dEither.$Either("Left", $0._1); }
+    if ($0.tag === "Right") { return Data$dEither.$Either("Right", Effect$dException.error($0._1)); }
+    $runtime.fail();
+  })());
+  if ($0.tag === "Left") { return Effect$dException.error("Promise failed, couldn't extract JS Error or String"); }
+  if ($0.tag === "Right") { return $0._1; }
+  $runtime.fail();
+};
+const toAff = /* #__PURE__ */ toAff$p(coerce);
+const toAffE = f => Effect$dAff._bind(Effect$dAff._liftEffect(f))(toAff$p(coerce));
+export {alt, coerce, fromAff, toAff, toAff$p, toAffE};
+export * from "./foreign.js";

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

@@ -0,0 +1,4 @@
+const semigroupoidFn = {compose: f => g => x => f(g(x))};
+const compose = dict => dict.compose;
+const composeFlipped = dictSemigroupoid => f => g => dictSemigroupoid.compose(g)(f);
+export {compose, composeFlipped, semigroupoidFn};

package/output-es/Data.Argonaut.Core/foreign.js

@@ -0,0 +1,102 @@
+/* eslint-disable no-eq-null, eqeqeq */
+function id(x) {
+  return x;
+}
+
+export {id as fromBoolean};
+export {id as fromNumber};
+export {id as fromString};
+export {id as fromArray};
+export {id as fromObject};
+export const jsonNull = null;
+
+export function stringify(j) {
+  return JSON.stringify(j);
+}
+
+export function stringifyWithIndent(i) {
+  return function (j) {
+    return JSON.stringify(j, null, i);
+  };
+}
+
+function isArray(a) {
+  return Object.prototype.toString.call(a) === "[object Array]";
+}
+
+export function _caseJson(isNull, isBool, isNum, isStr, isArr, isObj, j) {
+  if (j == null) return isNull();
+  else if (typeof j === "boolean") return isBool(j);
+  else if (typeof j === "number") return isNum(j);
+  else if (typeof j === "string") return isStr(j);
+  else if (Object.prototype.toString.call(j) === "[object Array]")
+    return isArr(j);
+  else return isObj(j);
+}
+
+export function _compare(EQ, GT, LT, a, b) {
+  if (a == null) {
+    if (b == null) return EQ;
+    else return LT;
+  } else if (typeof a === "boolean") {
+    if (typeof b === "boolean") {
+      // boolean / boolean
+      if (a === b) return EQ;
+      else if (a === false) return LT;
+      else return GT;
+    } else if (b == null) return GT;
+    else return LT;
+  } else if (typeof a === "number") {
+    if (typeof b === "number") {
+      if (a === b) return EQ;
+      else if (a < b) return LT;
+      else return GT;
+    } else if (b == null) return GT;
+    else if (typeof b === "boolean") return GT;
+    else return LT;
+  } else if (typeof a === "string") {
+    if (typeof b === "string") {
+      if (a === b) return EQ;
+      else if (a < b) return LT;
+      else return GT;
+    } else if (b == null) return GT;
+    else if (typeof b === "boolean") return GT;
+    else if (typeof b === "number") return GT;
+    else return LT;
+  } else if (isArray(a)) {
+    if (isArray(b)) {
+      for (var i = 0; i < Math.min(a.length, b.length); i++) {
+        var ca = _compare(EQ, GT, LT, a[i], b[i]);
+        if (ca !== EQ) return ca;
+      }
+      if (a.length === b.length) return EQ;
+      else if (a.length < b.length) return LT;
+      else return GT;
+    } else if (b == null) return GT;
+    else if (typeof b === "boolean") return GT;
+    else if (typeof b === "number") return GT;
+    else if (typeof b === "string") return GT;
+    else return LT;
+  } else {
+    if (b == null) return GT;
+    else if (typeof b === "boolean") return GT;
+    else if (typeof b === "number") return GT;
+    else if (typeof b === "string") return GT;
+    else if (isArray(b)) return GT;
+    else {
+      var akeys = Object.keys(a);
+      var bkeys = Object.keys(b);
+      if (akeys.length < bkeys.length) return LT;
+      else if (akeys.length > bkeys.length) return GT;
+      var keys = akeys.concat(bkeys).sort();
+      for (var j = 0; j < keys.length; j++) {
+        var k = keys[j];
+        if (a[k] === undefined) return LT;
+        else if (b[k] === undefined) return GT;
+        var ck = _compare(EQ, GT, LT, a[k], b[k]);
+        if (ck !== EQ) return ck;
+      }
+      return EQ;
+    }
+  }
+}