@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Control.Comonad.Env.Trans/index.js

@@ -0,0 +1,113 @@
+// | This module defines the environment comonad transformer, `EnvT`.
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const EnvT = x => x;
+const withEnvT = f => v => Data$dTuple.$Tuple(f(v._1), v._2);
+const runEnvT = v => v;
+const newtypeEnvT = {Coercible0: () => {}};
+const mapEnvT = f => v => Data$dTuple.$Tuple(v._1, f(v._2));
+const functorEnvT = dictFunctor => ({map: f => v => Data$dTuple.$Tuple(v._1, dictFunctor.map(f)(v._2))});
+const functorWithIndexEnvT = dictFunctorWithIndex => {
+  const $0 = dictFunctorWithIndex.Functor0();
+  const functorEnvT1 = {map: f => v => Data$dTuple.$Tuple(v._1, $0.map(f)(v._2))};
+  return {mapWithIndex: f => v => Data$dTuple.$Tuple(v._1, dictFunctorWithIndex.mapWithIndex(f)(v._2)), Functor0: () => functorEnvT1};
+};
+const foldableEnvT = dictFoldable => (
+  {
+    foldl: fn => a => v => dictFoldable.foldl(fn)(a)(v._2),
+    foldr: fn => a => v => dictFoldable.foldr(fn)(a)(v._2),
+    foldMap: dictMonoid => {
+      const foldMap1 = dictFoldable.foldMap(dictMonoid);
+      return fn => v => foldMap1(fn)(v._2);
+    }
+  }
+);
+const foldableWithIndexEnvT = dictFoldableWithIndex => {
+  const $0 = dictFoldableWithIndex.Foldable0();
+  const foldableEnvT1 = {
+    foldl: fn => a => v => $0.foldl(fn)(a)(v._2),
+    foldr: fn => a => v => $0.foldr(fn)(a)(v._2),
+    foldMap: dictMonoid => {
+      const foldMap1 = $0.foldMap(dictMonoid);
+      return fn => v => foldMap1(fn)(v._2);
+    }
+  };
+  return {
+    foldlWithIndex: f => a => v => dictFoldableWithIndex.foldlWithIndex(f)(a)(v._2),
+    foldrWithIndex: f => a => v => dictFoldableWithIndex.foldrWithIndex(f)(a)(v._2),
+    foldMapWithIndex: dictMonoid => {
+      const foldMapWithIndex1 = dictFoldableWithIndex.foldMapWithIndex(dictMonoid);
+      return f => v => foldMapWithIndex1(f)(v._2);
+    },
+    Foldable0: () => foldableEnvT1
+  };
+};
+const traversableEnvT = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const functorEnvT1 = {map: f => v => Data$dTuple.$Tuple(v._1, $0.map(f)(v._2))};
+  const $1 = dictTraversable.Foldable1();
+  const foldableEnvT1 = {
+    foldl: fn => a => v => $1.foldl(fn)(a)(v._2),
+    foldr: fn => a => v => $1.foldr(fn)(a)(v._2),
+    foldMap: dictMonoid => {
+      const foldMap1 = $1.foldMap(dictMonoid);
+      return fn => v => foldMap1(fn)(v._2);
+    }
+  };
+  return {
+    sequence: dictApplicative => {
+      const sequence1 = dictTraversable.sequence(dictApplicative);
+      return v => dictApplicative.Apply0().Functor0().map(Data$dTuple.Tuple(v._1))(sequence1(v._2));
+    },
+    traverse: dictApplicative => {
+      const traverse1 = dictTraversable.traverse(dictApplicative);
+      return f => v => dictApplicative.Apply0().Functor0().map(Data$dTuple.Tuple(v._1))(traverse1(f)(v._2));
+    },
+    Functor0: () => functorEnvT1,
+    Foldable1: () => foldableEnvT1
+  };
+};
+const traversableWithIndexEnvT = dictTraversableWithIndex => {
+  const $0 = dictTraversableWithIndex.FunctorWithIndex0();
+  const $1 = $0.Functor0();
+  const functorWithIndexEnvT1 = (() => {
+    const functorEnvT1 = {map: f => v => Data$dTuple.$Tuple(v._1, $1.map(f)(v._2))};
+    return {mapWithIndex: f => v => Data$dTuple.$Tuple(v._1, $0.mapWithIndex(f)(v._2)), Functor0: () => functorEnvT1};
+  })();
+  const foldableWithIndexEnvT1 = foldableWithIndexEnvT(dictTraversableWithIndex.FoldableWithIndex1());
+  const traversableEnvT1 = traversableEnvT(dictTraversableWithIndex.Traversable2());
+  return {
+    traverseWithIndex: dictApplicative => {
+      const traverseWithIndex1 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+      return f => v => dictApplicative.Apply0().Functor0().map(Data$dTuple.Tuple(v._1))(traverseWithIndex1(f)(v._2));
+    },
+    FunctorWithIndex0: () => functorWithIndexEnvT1,
+    FoldableWithIndex1: () => foldableWithIndexEnvT1,
+    Traversable2: () => traversableEnvT1
+  };
+};
+const extendEnvT = dictExtend => {
+  const Functor0 = dictExtend.Functor0();
+  const functorEnvT1 = {map: f => v => Data$dTuple.$Tuple(v._1, Functor0.map(f)(v._2))};
+  return {extend: f => v => Data$dTuple.$Tuple(v._1, Functor0.map(f)(dictExtend.extend(Data$dTuple.Tuple(v._1))(v._2))), Functor0: () => functorEnvT1};
+};
+const comonadTransEnvT = {lower: dictComonad => v => v._2};
+const comonadEnvT = dictComonad => {
+  const extendEnvT1 = extendEnvT(dictComonad.Extend0());
+  return {extract: v => dictComonad.extract(v._2), Extend0: () => extendEnvT1};
+};
+export {
+  EnvT,
+  comonadEnvT,
+  comonadTransEnvT,
+  extendEnvT,
+  foldableEnvT,
+  foldableWithIndexEnvT,
+  functorEnvT,
+  functorWithIndexEnvT,
+  mapEnvT,
+  newtypeEnvT,
+  runEnvT,
+  traversableEnvT,
+  traversableWithIndexEnvT,
+  withEnvT
+};

package/output-es/Control.Comonad.Store/index.js

@@ -0,0 +1,5 @@
+// | This module defines the `Store` comonad.
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const store = f => x => Data$dTuple.$Tuple(f, x);
+const runStore = v => Data$dTuple.$Tuple(v._1, v._2);
+export {runStore, store};

package/output-es/Control.Comonad.Store.Class/index.js

@@ -0,0 +1,56 @@
+// | This module defines the `ComonadStore` type class and its instances.
+import * as Control$dComonad$dEnv$dTrans from "../Control.Comonad.Env.Trans/index.js";
+import * as Control$dComonad$dStore$dTrans from "../Control.Comonad.Store.Trans/index.js";
+import * as Control$dComonad$dTraced$dTrans from "../Control.Comonad.Traced.Trans/index.js";
+import * as Control$dExtend from "../Control.Extend/index.js";
+const pos = dict => dict.pos;
+const peek = dict => dict.peek;
+const peeks = dictComonadStore => f => x => dictComonadStore.peek(f(dictComonadStore.pos(x)))(x);
+const seeks = dictComonadStore => {
+  const duplicate = dictComonadStore.Comonad0().Extend0().extend(Control$dExtend.identity);
+  return f => x => {
+    const $0 = duplicate(x);
+    return dictComonadStore.peek(f(dictComonadStore.pos($0)))($0);
+  };
+};
+const seek = dictComonadStore => {
+  const duplicate = dictComonadStore.Comonad0().Extend0().extend(Control$dExtend.identity);
+  return s => {
+    const $0 = dictComonadStore.peek(s);
+    return x => $0(duplicate(x));
+  };
+};
+const experiment = dictComonadStore => dictFunctor => f => x => dictFunctor.map(a => dictComonadStore.peek(a)(x))(f(dictComonadStore.pos(x)));
+const comonadStoreTracedT = dictComonadStore => {
+  const Comonad0 = dictComonadStore.Comonad0();
+  const comonadTracedT = Control$dComonad$dTraced$dTrans.comonadTracedT(Comonad0);
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const lower1 = v => Comonad0.Extend0().Functor0().map(f => f(mempty))(v);
+    const comonadTracedT1 = comonadTracedT(dictMonoid);
+    return {
+      pos: x => dictComonadStore.pos(lower1(x)),
+      peek: s => {
+        const $0 = dictComonadStore.peek(s);
+        return x => $0(lower1(x));
+      },
+      Comonad0: () => comonadTracedT1
+    };
+  };
+};
+const comonadStoreStoreT = dictComonad => {
+  const comonadStoreT = Control$dComonad$dStore$dTrans.comonadStoreT(dictComonad);
+  return {pos: v => v._2, peek: s => v => dictComonad.extract(v._1)(s), Comonad0: () => comonadStoreT};
+};
+const comonadStoreEnvT = dictComonadStore => {
+  const comonadEnvT = Control$dComonad$dEnv$dTrans.comonadEnvT(dictComonadStore.Comonad0());
+  return {
+    pos: x => dictComonadStore.pos(x._2),
+    peek: s => {
+      const $0 = dictComonadStore.peek(s);
+      return x => $0(x._2);
+    },
+    Comonad0: () => comonadEnvT
+  };
+};
+export {comonadStoreEnvT, comonadStoreStoreT, comonadStoreTracedT, experiment, peek, peeks, pos, seek, seeks};

package/output-es/Control.Comonad.Store.Trans/index.js

@@ -0,0 +1,27 @@
+// | This module defines the store comonad transformer, `StoreT`.
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const StoreT = x => x;
+const runStoreT = v => v;
+const newtypeStoreT = {Coercible0: () => {}};
+const functorStoreT = dictFunctor => ({map: f => v => Data$dTuple.$Tuple(dictFunctor.map(h => x => f(h(x)))(v._1), v._2)});
+const extendStoreT = dictExtend => {
+  const $0 = dictExtend.Functor0();
+  const functorStoreT1 = {map: f => v => Data$dTuple.$Tuple($0.map(h => x => f(h(x)))(v._1), v._2)};
+  return {extend: f => v => Data$dTuple.$Tuple(dictExtend.extend(w$p => s$p => f(Data$dTuple.$Tuple(w$p, s$p)))(v._1), v._2), Functor0: () => functorStoreT1};
+};
+const comonadTransStoreT = {
+  lower: dictComonad => v => {
+    const $0 = v._2;
+    return dictComonad.Extend0().Functor0().map(v1 => v1($0))(v._1);
+  }
+};
+const comonadStoreT = dictComonad => {
+  const $0 = dictComonad.Extend0();
+  const $1 = $0.Functor0();
+  const extendStoreT1 = (() => {
+    const functorStoreT1 = {map: f => v => Data$dTuple.$Tuple($1.map(h => x => f(h(x)))(v._1), v._2)};
+    return {extend: f => v => Data$dTuple.$Tuple($0.extend(w$p => s$p => f(Data$dTuple.$Tuple(w$p, s$p)))(v._1), v._2), Functor0: () => functorStoreT1};
+  })();
+  return {extract: v => dictComonad.extract(v._1)(v._2), Extend0: () => extendStoreT1};
+};
+export {StoreT, comonadStoreT, comonadTransStoreT, extendStoreT, functorStoreT, newtypeStoreT, runStoreT};

package/output-es/Control.Comonad.Traced/index.js

@@ -0,0 +1,4 @@
+// | This module defines the `Traced` comonad.
+const traced = x => x;
+const runTraced = v => v;
+export {runTraced, traced};

package/output-es/Control.Comonad.Traced.Class/index.js

@@ -0,0 +1,16 @@
+// | This module defines the `ComonadTraced` type class and its instances.
+import * as Control$dComonad$dTraced$dTrans from "../Control.Comonad.Traced.Trans/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const track = dict => dict.track;
+const tracks = dictComonadTraced => f => w => dictComonadTraced.track(f(dictComonadTraced.Comonad0().extract(w)))(w);
+const listens = dictFunctor => f => v => dictFunctor.map(g => t => Data$dTuple.$Tuple(g(t), f(t)))(v);
+const listen = dictFunctor => v => dictFunctor.map(f => t => Data$dTuple.$Tuple(f(t), t))(v);
+const comonadTracedTracedT = dictComonad => {
+  const comonadTracedT = Control$dComonad$dTraced$dTrans.comonadTracedT(dictComonad);
+  return dictMonoid => {
+    const comonadTracedT1 = comonadTracedT(dictMonoid);
+    return {track: t => v => dictComonad.extract(v)(t), Comonad0: () => comonadTracedT1};
+  };
+};
+const censor = dictFunctor => f => v => dictFunctor.map(v1 => x => v1(f(x)))(v);
+export {censor, comonadTracedTracedT, listen, listens, track, tracks};

package/output-es/Control.Comonad.Traced.Trans/index.js

@@ -0,0 +1,28 @@
+// | This module defines the cowriter comonad transformer, `TracedT`.
+const TracedT = x => x;
+const runTracedT = v => v;
+const newtypeTracedT = {Coercible0: () => {}};
+const functorTracedT = dictFunctor => ({map: f => v => dictFunctor.map(g => t => f(g(t)))(v)});
+const extendTracedT = dictExtend => {
+  const Functor0 = dictExtend.Functor0();
+  const functorTracedT1 = {map: f => v => Functor0.map(g => t => f(g(t)))(v)};
+  return dictSemigroup => ({extend: f => v => dictExtend.extend(w$p => t => f(Functor0.map(h => t$p => h(dictSemigroup.append(t)(t$p)))(w$p)))(v), Functor0: () => functorTracedT1});
+};
+const comonadTransTracedT = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return {lower: dictComonad => v => dictComonad.Extend0().Functor0().map(f => f(mempty))(v)};
+};
+const comonadTracedT = dictComonad => {
+  const $0 = dictComonad.Extend0();
+  const Functor0 = $0.Functor0();
+  const extendTracedT1 = (() => {
+    const functorTracedT1 = {map: f => v => Functor0.map(g => t => f(g(t)))(v)};
+    return dictSemigroup => ({extend: f => v => $0.extend(w$p => t => f(Functor0.map(h => t$p => h(dictSemigroup.append(t)(t$p)))(w$p)))(v), Functor0: () => functorTracedT1});
+  })();
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const extendTracedT2 = extendTracedT1(dictMonoid.Semigroup0());
+    return {extract: v => dictComonad.extract(v)(mempty), Extend0: () => extendTracedT2};
+  };
+};
+export {TracedT, comonadTracedT, comonadTransTracedT, extendTracedT, functorTracedT, newtypeTracedT, runTracedT};

package/output-es/Control.Comonad.Trans.Class/index.js

@@ -0,0 +1,3 @@
+// | This module defines the `ComonadTrans` type class of _comonad transformers_.
+const lower = dict => dict.lower;
+export {lower};

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

@@ -0,0 +1,7 @@
+export const arrayExtend = function(f) {
+  return function(xs) {
+    return xs.map(function (_, i, xs) {
+      return f(xs.slice(i));
+    });
+  };
+};

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

@@ -0,0 +1,12 @@
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import {arrayExtend} from "./foreign.js";
+const identity = x => x;
+const extendFn = dictSemigroup => ({extend: f => g => w => f(w$p => g(dictSemigroup.append(w)(w$p))), Functor0: () => Data$dFunctor.functorFn});
+const extendArray = {extend: arrayExtend, Functor0: () => Data$dFunctor.functorArray};
+const extend = dict => dict.extend;
+const extendFlipped = dictExtend => w => f => dictExtend.extend(f)(w);
+const duplicate = dictExtend => dictExtend.extend(identity);
+const composeCoKleisliFlipped = dictExtend => f => g => w => f(dictExtend.extend(g)(w));
+const composeCoKleisli = dictExtend => f => g => w => g(dictExtend.extend(f)(w));
+export {composeCoKleisli, composeCoKleisliFlipped, duplicate, extend, extendArray, extendFlipped, extendFn, identity};
+export * from "./foreign.js";

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

@@ -0,0 +1,10 @@
+import * as $runtime from "../runtime.js";
+const lazyUnit = {defer: v => {}};
+const lazyFn = {defer: f => x => f()(x)};
+const defer = dict => dict.defer;
+const fix = dictLazy => f => {
+  const go$lazy = $runtime.binding(() => dictLazy.defer(v => f(go$lazy())));
+  const go = go$lazy();
+  return go;
+};
+export {defer, fix, lazyFn, lazyUnit};

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

@@ -0,0 +1,27 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dApplicative from "../Control.Applicative/index.js";
+import * as Control$dBind from "../Control.Bind/index.js";
+const whenM = dictMonad => {
+  const $0 = dictMonad.Applicative0();
+  return mb => m => dictMonad.Bind1().bind(mb)(b => {
+    if (b) { return m; }
+    return $0.pure();
+  });
+};
+const unlessM = dictMonad => {
+  const $0 = dictMonad.Applicative0();
+  return mb => m => dictMonad.Bind1().bind(mb)(b => {
+    if (!b) { return m; }
+    if (b) { return $0.pure(); }
+    $runtime.fail();
+  });
+};
+const monadProxy = {Applicative0: () => Control$dApplicative.applicativeProxy, Bind1: () => Control$dBind.bindProxy};
+const monadFn = {Applicative0: () => Control$dApplicative.applicativeFn, Bind1: () => Control$dBind.bindFn};
+const monadArray = {Applicative0: () => Control$dApplicative.applicativeArray, Bind1: () => Control$dBind.bindArray};
+const liftM1 = dictMonad => f => a => dictMonad.Bind1().bind(a)(a$p => dictMonad.Applicative0().pure(f(a$p)));
+const ap = dictMonad => {
+  const $0 = dictMonad.Bind1();
+  return f => a => $0.bind(f)(f$p => $0.bind(a)(a$p => dictMonad.Applicative0().pure(f$p(a$p))));
+};
+export {ap, liftM1, monadArray, monadFn, monadProxy, unlessM, whenM};

package/output-es/Control.Monad.Cont/index.js

@@ -0,0 +1,6 @@
+// | This module defines the `Cont`inuation monad.
+const withCont = f => v => k => v(f(x => k(x)));
+const runCont = cc => k => cc(x => k(x));
+const mapCont = f => v => k => f(v(k));
+const cont = f => c => f(x => c(x));
+export {cont, mapCont, runCont, withCont};

package/output-es/Control.Monad.Cont.Class/index.js

@@ -0,0 +1,3 @@
+// | This module defines the `MonadCont` type class and its instances.
+const callCC = dict => dict.callCC;
+export {callCC};

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

@@ -0,0 +1,122 @@
+// | This module defines the CPS monad transformer.
+const ContT = x => x;
+const withContT = f => v => k => v(f(k));
+const runContT = v => k => v(k);
+const newtypeContT = {Coercible0: () => {}};
+const monadTransContT = {lift: dictMonad => dictMonad.Bind1().bind};
+const mapContT = f => v => k => f(v(k));
+const functorContT = dictFunctor => ({map: f => v => k => v(a => k(f(a)))});
+const applyContT = dictApply => {
+  const functorContT1 = {map: f => v => k => v(a => k(f(a)))};
+  return {apply: v => v1 => k => v(g => v1(a => k(g(a)))), Functor0: () => functorContT1};
+};
+const bindContT = dictBind => {
+  const functorContT1 = {map: f => v => k => v(a => k(f(a)))};
+  const applyContT1 = {apply: v => v1 => k => v(g => v1(a => k(g(a)))), Functor0: () => functorContT1};
+  return {bind: v => k => k$p => v(a => k(a)(k$p)), Apply0: () => applyContT1};
+};
+const semigroupContT = dictApply => dictSemigroup => (
+  {
+    append: a => b => k => a(a$1 => {
+      const $0 = dictSemigroup.append(a$1);
+      return b(a$2 => k($0(a$2)));
+    })
+  }
+);
+const applicativeContT = dictApplicative => {
+  const functorContT1 = {map: f => v => k => v(a => k(f(a)))};
+  const applyContT1 = {apply: v => v1 => k => v(g => v1(a => k(g(a)))), Functor0: () => functorContT1};
+  return {pure: a => k => k(a), Apply0: () => applyContT1};
+};
+const monadContT = dictMonad => {
+  const functorContT1 = {map: f => v => k => v(a => k(f(a)))};
+  const applicativeContT1 = (() => {
+    const applyContT1 = {apply: v => v1 => k => v(g => v1(a => k(g(a)))), Functor0: () => functorContT1};
+    return {pure: a => k => k(a), Apply0: () => applyContT1};
+  })();
+  const functorContT1$1 = {map: f => v => k => v(a => k(f(a)))};
+  const bindContT1 = (() => {
+    const applyContT1 = {apply: v => v1 => k => v(g => v1(a => k(g(a)))), Functor0: () => functorContT1$1};
+    return {bind: v => k => k$p => v(a => k(a)(k$p)), Apply0: () => applyContT1};
+  })();
+  return {Applicative0: () => applicativeContT1, Bind1: () => bindContT1};
+};
+const monadAskContT = dictMonadAsk => {
+  const Monad0 = dictMonadAsk.Monad0();
+  const monadContT1 = monadContT(Monad0);
+  return {ask: Monad0.Bind1().bind(dictMonadAsk.ask), Monad0: () => monadContT1};
+};
+const monadReaderContT = dictMonadReader => {
+  const MonadAsk0 = dictMonadReader.MonadAsk0();
+  const ask = MonadAsk0.ask;
+  const monadAskContT1 = monadAskContT(MonadAsk0);
+  return {
+    local: f => v => k => MonadAsk0.Monad0().Bind1().bind(ask)(r => dictMonadReader.local(f)(v((() => {
+      const $0 = dictMonadReader.local(v$1 => r);
+      return x => $0(k(x));
+    })()))),
+    MonadAsk0: () => monadAskContT1
+  };
+};
+const monadContContT = dictMonad => {
+  const monadContT1 = monadContT(dictMonad);
+  return {callCC: f => k => f(a => v1 => k(a))(k), Monad0: () => monadContT1};
+};
+const monadEffectContT = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const monadContT1 = monadContT(Monad0);
+  return {
+    liftEffect: (() => {
+      const $0 = Monad0.Bind1().bind;
+      return x => $0(dictMonadEffect.liftEffect(x));
+    })(),
+    Monad0: () => monadContT1
+  };
+};
+const monadStateContT = dictMonadState => {
+  const Monad0 = dictMonadState.Monad0();
+  const monadContT1 = monadContT(Monad0);
+  return {
+    state: (() => {
+      const $0 = Monad0.Bind1().bind;
+      return x => $0(dictMonadState.state(x));
+    })(),
+    Monad0: () => monadContT1
+  };
+};
+const monoidContT = dictApplicative => dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const semigroupContT2 = {
+    append: a => b => k => a(a$1 => {
+      const $1 = $0.append(a$1);
+      return b(a$2 => k($1(a$2)));
+    })
+  };
+  return {
+    mempty: (() => {
+      const $1 = dictMonoid.mempty;
+      return k => k($1);
+    })(),
+    Semigroup0: () => semigroupContT2
+  };
+};
+export {
+  ContT,
+  applicativeContT,
+  applyContT,
+  bindContT,
+  functorContT,
+  mapContT,
+  monadAskContT,
+  monadContContT,
+  monadContT,
+  monadEffectContT,
+  monadReaderContT,
+  monadStateContT,
+  monadTransContT,
+  monoidContT,
+  newtypeContT,
+  runContT,
+  semigroupContT,
+  withContT
+};

package/output-es/Control.Monad.Error.Class/index.js

@@ -0,0 +1,83 @@
+// | This module defines the `MonadError` type class and its instances.
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Effect from "../Effect/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+const throwError = dict => dict.throwError;
+const monadThrowMaybe = {throwError: v => Data$dMaybe.Nothing, Monad0: () => Data$dMaybe.monadMaybe};
+const monadThrowEither = {throwError: Data$dEither.Left, Monad0: () => Data$dEither.monadEither};
+const monadThrowEffect = {throwError: Effect$dException.throwException, Monad0: () => Effect.monadEffect};
+const monadErrorMaybe = {
+  catchError: v => v1 => {
+    if (v.tag === "Nothing") { return v1(); }
+    if (v.tag === "Just") { return Data$dMaybe.$Maybe("Just", v._1); }
+    $runtime.fail();
+  },
+  MonadThrow0: () => monadThrowMaybe
+};
+const monadErrorEither = {
+  catchError: v => v1 => {
+    if (v.tag === "Left") { return v1(v._1); }
+    if (v.tag === "Right") { return Data$dEither.$Either("Right", v._1); }
+    $runtime.fail();
+  },
+  MonadThrow0: () => monadThrowEither
+};
+const monadErrorEffect = {catchError: b => a => Effect$dException.catchException(a)(b), MonadThrow0: () => monadThrowEffect};
+const liftMaybe = dictMonadThrow => {
+  const pure = dictMonadThrow.Monad0().Applicative0().pure;
+  return error => {
+    const $0 = dictMonadThrow.throwError(error);
+    return v2 => {
+      if (v2.tag === "Nothing") { return $0; }
+      if (v2.tag === "Just") { return pure(v2._1); }
+      $runtime.fail();
+    };
+  };
+};
+const liftEither = dictMonadThrow => {
+  const $0 = dictMonadThrow.Monad0().Applicative0().pure;
+  return v2 => {
+    if (v2.tag === "Left") { return dictMonadThrow.throwError(v2._1); }
+    if (v2.tag === "Right") { return $0(v2._1); }
+    $runtime.fail();
+  };
+};
+const catchError = dict => dict.catchError;
+const catchJust = dictMonadError => p => act => handler => dictMonadError.catchError(act)(e => {
+  const v = p(e);
+  if (v.tag === "Nothing") { return dictMonadError.MonadThrow0().throwError(e); }
+  if (v.tag === "Just") { return handler(v._1); }
+  $runtime.fail();
+});
+const $$try = dictMonadError => {
+  const Monad0 = dictMonadError.MonadThrow0().Monad0();
+  return a => dictMonadError.catchError(Monad0.Bind1().Apply0().Functor0().map(Data$dEither.Right)(a))(x => Monad0.Applicative0().pure(Data$dEither.$Either("Left", x)));
+};
+const withResource = dictMonadError => {
+  const MonadThrow0 = dictMonadError.MonadThrow0();
+  const Monad0 = MonadThrow0.Monad0();
+  const Bind1 = Monad0.Bind1();
+  const try1 = $$try(dictMonadError);
+  return acquire => release => kleisli => Bind1.bind(acquire)(resource => Bind1.bind(try1(kleisli(resource)))(result => Bind1.bind(release(resource))(() => {
+    if (result.tag === "Left") { return MonadThrow0.throwError(result._1); }
+    if (result.tag === "Right") { return Monad0.Applicative0().pure(result._1); }
+    $runtime.fail();
+  })));
+};
+export {
+  catchError,
+  catchJust,
+  liftEither,
+  liftMaybe,
+  monadErrorEffect,
+  monadErrorEither,
+  monadErrorMaybe,
+  monadThrowEffect,
+  monadThrowEither,
+  monadThrowMaybe,
+  throwError,
+  $$try as try,
+  withResource
+};

package/output-es/Control.Monad.Except/index.js

@@ -0,0 +1,10 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+const withExcept = f => v => {
+  if (v.tag === "Right") { return Data$dEither.$Either("Right", v._1); }
+  if (v.tag === "Left") { return Data$dEither.$Either("Left", f(v._1)); }
+  $runtime.fail();
+};
+const runExcept = x => x;
+const mapExcept = f => v => f(v);
+export {mapExcept, runExcept, withExcept};