@explorable-viz/fluid 0.12.2 → 0.12.4

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

@@ -0,0 +1,217 @@
+// | This module defines the `MaybeT` monad transformer.
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dRec$dClass from "../Control.Monad.Rec.Class/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const identity = x => x;
+const MaybeT = x => x;
+const runMaybeT = v => v;
+const newtypeMaybeT = {Coercible0: () => {}};
+const monadTransMaybeT = {lift: dictMonad => x => dictMonad.Bind1().bind(x)(a$p => dictMonad.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p)))};
+const mapMaybeT = f => v => f(v);
+const functorMaybeT = dictFunctor => (
+  {
+    map: f => v => dictFunctor.map(v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", f(v1._1)); }
+      return Data$dMaybe.Nothing;
+    })(v)
+  }
+);
+const monadMaybeT = dictMonad => ({Applicative0: () => applicativeMaybeT(dictMonad), Bind1: () => bindMaybeT(dictMonad)});
+const bindMaybeT = dictMonad => (
+  {
+    bind: v => f => dictMonad.Bind1().bind(v)(v1 => {
+      if (v1.tag === "Nothing") { return dictMonad.Applicative0().pure(Data$dMaybe.Nothing); }
+      if (v1.tag === "Just") { return f(v1._1); }
+      $runtime.fail();
+    }),
+    Apply0: () => applyMaybeT(dictMonad)
+  }
+);
+const applyMaybeT = dictMonad => {
+  const $0 = dictMonad.Bind1().Apply0().Functor0();
+  const functorMaybeT1 = {
+    map: f => v => $0.map(v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", f(v1._1)); }
+      return Data$dMaybe.Nothing;
+    })(v)
+  };
+  return {
+    apply: (() => {
+      const $1 = bindMaybeT(dictMonad);
+      return f => a => $1.bind(f)(f$p => $1.bind(a)(a$p => applicativeMaybeT(dictMonad).pure(f$p(a$p))));
+    })(),
+    Functor0: () => functorMaybeT1
+  };
+};
+const applicativeMaybeT = dictMonad => ({pure: x => dictMonad.Applicative0().pure(Data$dMaybe.$Maybe("Just", x)), Apply0: () => applyMaybeT(dictMonad)});
+const semigroupMaybeT = dictMonad => {
+  const $0 = applyMaybeT(dictMonad);
+  return dictSemigroup => (
+    {
+      append: (() => {
+        const $1 = dictSemigroup.append;
+        return a => b => $0.apply($0.Functor0().map($1)(a))(b);
+      })()
+    }
+  );
+};
+const monadAskMaybeT = dictMonadAsk => {
+  const Monad0 = dictMonadAsk.Monad0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(Monad0), Bind1: () => bindMaybeT(Monad0)};
+  return {ask: Monad0.Bind1().bind(dictMonadAsk.ask)(a$p => Monad0.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p))), Monad0: () => monadMaybeT1};
+};
+const monadReaderMaybeT = dictMonadReader => {
+  const monadAskMaybeT1 = monadAskMaybeT(dictMonadReader.MonadAsk0());
+  return {local: f => dictMonadReader.local(f), MonadAsk0: () => monadAskMaybeT1};
+};
+const monadContMaybeT = dictMonadCont => {
+  const $0 = dictMonadCont.Monad0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT($0), Bind1: () => bindMaybeT($0)};
+  return {callCC: f => dictMonadCont.callCC(c => f(a => c(Data$dMaybe.$Maybe("Just", a)))), Monad0: () => monadMaybeT1};
+};
+const monadEffectMaybe = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(Monad0), Bind1: () => bindMaybeT(Monad0)};
+  return {liftEffect: x => Monad0.Bind1().bind(dictMonadEffect.liftEffect(x))(a$p => Monad0.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p))), Monad0: () => monadMaybeT1};
+};
+const monadRecMaybeT = dictMonadRec => {
+  const Monad0 = dictMonadRec.Monad0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(Monad0), Bind1: () => bindMaybeT(Monad0)};
+  return {
+    tailRecM: f => dictMonadRec.tailRecM(a => Monad0.Bind1().bind(f(a))(m$p => Monad0.Applicative0().pure((() => {
+      if (m$p.tag === "Nothing") { return Control$dMonad$dRec$dClass.$Step("Done", Data$dMaybe.Nothing); }
+      if (m$p.tag === "Just") {
+        if (m$p._1.tag === "Loop") { return Control$dMonad$dRec$dClass.$Step("Loop", m$p._1._1); }
+        if (m$p._1.tag === "Done") { return Control$dMonad$dRec$dClass.$Step("Done", Data$dMaybe.$Maybe("Just", m$p._1._1)); }
+      }
+      $runtime.fail();
+    })()))),
+    Monad0: () => monadMaybeT1
+  };
+};
+const monadStateMaybeT = dictMonadState => {
+  const Monad0 = dictMonadState.Monad0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(Monad0), Bind1: () => bindMaybeT(Monad0)};
+  return {state: f => Monad0.Bind1().bind(dictMonadState.state(f))(a$p => Monad0.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p))), Monad0: () => monadMaybeT1};
+};
+const monadTellMaybeT = dictMonadTell => {
+  const Monad1 = dictMonadTell.Monad1();
+  const Semigroup0 = dictMonadTell.Semigroup0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(Monad1), Bind1: () => bindMaybeT(Monad1)};
+  return {
+    tell: x => Monad1.Bind1().bind(dictMonadTell.tell(x))(a$p => Monad1.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p))),
+    Semigroup0: () => Semigroup0,
+    Monad1: () => monadMaybeT1
+  };
+};
+const monadWriterMaybeT = dictMonadWriter => {
+  const MonadTell1 = dictMonadWriter.MonadTell1();
+  const Monad1 = MonadTell1.Monad1();
+  const $0 = Monad1.Bind1();
+  const $1 = Monad1.Applicative0();
+  const Monoid0 = dictMonadWriter.Monoid0();
+  const monadTellMaybeT1 = monadTellMaybeT(MonadTell1);
+  return {
+    listen: v => $0.bind(dictMonadWriter.listen(v))(v$1 => $1.pure(v$1._1.tag === "Just" ? Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(v$1._1._1, v$1._2)) : Data$dMaybe.Nothing)),
+    pass: v => dictMonadWriter.pass($0.bind(v)(a => $1.pure((() => {
+      if (a.tag === "Nothing") { return Data$dTuple.$Tuple(Data$dMaybe.Nothing, identity); }
+      if (a.tag === "Just") { return Data$dTuple.$Tuple(Data$dMaybe.$Maybe("Just", a._1._1), a._1._2); }
+      $runtime.fail();
+    })()))),
+    Monoid0: () => Monoid0,
+    MonadTell1: () => monadTellMaybeT1
+  };
+};
+const monadThrowMaybeT = dictMonadThrow => {
+  const Monad0 = dictMonadThrow.Monad0();
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(Monad0), Bind1: () => bindMaybeT(Monad0)};
+  return {throwError: e => Monad0.Bind1().bind(dictMonadThrow.throwError(e))(a$p => Monad0.Applicative0().pure(Data$dMaybe.$Maybe("Just", a$p))), Monad0: () => monadMaybeT1};
+};
+const monadErrorMaybeT = dictMonadError => {
+  const monadThrowMaybeT1 = monadThrowMaybeT(dictMonadError.MonadThrow0());
+  return {catchError: v => h => dictMonadError.catchError(v)(a => h(a)), MonadThrow0: () => monadThrowMaybeT1};
+};
+const monoidMaybeT = dictMonad => {
+  const semigroupMaybeT1 = semigroupMaybeT(dictMonad);
+  return dictMonoid => {
+    const semigroupMaybeT2 = semigroupMaybeT1(dictMonoid.Semigroup0());
+    return {mempty: applicativeMaybeT(dictMonad).pure(dictMonoid.mempty), Semigroup0: () => semigroupMaybeT2};
+  };
+};
+const altMaybeT = dictMonad => {
+  const Bind1 = dictMonad.Bind1();
+  const $0 = Bind1.Apply0().Functor0();
+  const functorMaybeT1 = {
+    map: f => v => $0.map(v1 => {
+      if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", f(v1._1)); }
+      return Data$dMaybe.Nothing;
+    })(v)
+  };
+  return {
+    alt: v => v1 => Bind1.bind(v)(m => {
+      if (m.tag === "Nothing") { return v1; }
+      return dictMonad.Applicative0().pure(m);
+    }),
+    Functor0: () => functorMaybeT1
+  };
+};
+const plusMaybeT = dictMonad => {
+  const Bind1 = dictMonad.Bind1();
+  const $0 = Bind1.Apply0().Functor0();
+  const altMaybeT1 = (() => {
+    const functorMaybeT1 = {
+      map: f => v => $0.map(v1 => {
+        if (v1.tag === "Just") { return Data$dMaybe.$Maybe("Just", f(v1._1)); }
+        return Data$dMaybe.Nothing;
+      })(v)
+    };
+    return {
+      alt: v => v1 => Bind1.bind(v)(m => {
+        if (m.tag === "Nothing") { return v1; }
+        return dictMonad.Applicative0().pure(m);
+      }),
+      Functor0: () => functorMaybeT1
+    };
+  })();
+  return {empty: dictMonad.Applicative0().pure(Data$dMaybe.Nothing), Alt0: () => altMaybeT1};
+};
+const alternativeMaybeT = dictMonad => {
+  const applicativeMaybeT1 = applicativeMaybeT(dictMonad);
+  const plusMaybeT1 = plusMaybeT(dictMonad);
+  return {Applicative0: () => applicativeMaybeT1, Plus1: () => plusMaybeT1};
+};
+const monadPlusMaybeT = dictMonad => {
+  const monadMaybeT1 = {Applicative0: () => applicativeMaybeT(dictMonad), Bind1: () => bindMaybeT(dictMonad)};
+  const alternativeMaybeT1 = alternativeMaybeT(dictMonad);
+  return {Monad0: () => monadMaybeT1, Alternative1: () => alternativeMaybeT1};
+};
+export {
+  MaybeT,
+  altMaybeT,
+  alternativeMaybeT,
+  applicativeMaybeT,
+  applyMaybeT,
+  bindMaybeT,
+  functorMaybeT,
+  identity,
+  mapMaybeT,
+  monadAskMaybeT,
+  monadContMaybeT,
+  monadEffectMaybe,
+  monadErrorMaybeT,
+  monadMaybeT,
+  monadPlusMaybeT,
+  monadReaderMaybeT,
+  monadRecMaybeT,
+  monadStateMaybeT,
+  monadTellMaybeT,
+  monadThrowMaybeT,
+  monadTransMaybeT,
+  monadWriterMaybeT,
+  monoidMaybeT,
+  newtypeMaybeT,
+  plusMaybeT,
+  runMaybeT,
+  semigroupMaybeT
+};

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

@@ -0,0 +1,16 @@
+// | This module defines the `RWS` monad.
+import * as Control$dMonad$dRWS$dTrans from "../Control.Monad.RWS.Trans/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const withRWS = Control$dMonad$dRWS$dTrans.withRWST;
+const rws = f => r => s => f(r)(s);
+const runRWS = m => r => s => m(r)(s);
+const mapRWS = f => v => r => s => f(v(r)(s));
+const execRWS = m => r => s => {
+  const $0 = m(r)(s);
+  return Data$dTuple.$Tuple($0._1, $0._3);
+};
+const evalRWS = m => r => s => {
+  const $0 = m(r)(s);
+  return Data$dTuple.$Tuple($0._2, $0._3);
+};
+export {evalRWS, execRWS, mapRWS, runRWS, rws, withRWS};

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

@@ -0,0 +1,260 @@
+// | This module defines the reader-writer-state monad transformer, `RWST`.
+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 $RWSResult = (_1, _2, _3) => ({tag: "RWSResult", _1, _2, _3});
+const RWSResult = value0 => value1 => value2 => $RWSResult(value0, value1, value2);
+const RWST = x => x;
+const withRWST = f => m => r => s => {
+  const $0 = f(r)(s);
+  return m($0._1)($0._2);
+};
+const runRWST = v => v;
+const newtypeRWST = {Coercible0: () => {}};
+const monadTransRWST = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return {lift: dictMonad => m => v => s => dictMonad.Bind1().bind(m)(a => dictMonad.Applicative0().pure($RWSResult(s, a, mempty)))};
+};
+const mapRWST = f => v => r => s => f(v(r)(s));
+const lazyRWST = {defer: f => r => s => f()(r)(s)};
+const functorRWST = dictFunctor => ({map: f => v => r => s => dictFunctor.map(v1 => $RWSResult(v1._1, f(v1._2), v1._3))(v(r)(s))});
+const execRWST = dictMonad => v => r => s => dictMonad.Bind1().bind(v(r)(s))(v1 => dictMonad.Applicative0().pure(Data$dTuple.$Tuple(v1._1, v1._3)));
+const evalRWST = dictMonad => v => r => s => dictMonad.Bind1().bind(v(r)(s))(v1 => dictMonad.Applicative0().pure(Data$dTuple.$Tuple(v1._2, v1._3)));
+const applyRWST = dictBind => {
+  const Functor0 = dictBind.Apply0().Functor0();
+  const functorRWST1 = {map: f => v => r => s => Functor0.map(v1 => $RWSResult(v1._1, f(v1._2), v1._3))(v(r)(s))};
+  return dictMonoid => (
+    {
+      apply: v => v1 => r => s => dictBind.bind(v(r)(s))(v2 => {
+        const $0 = v2._3;
+        return Functor0.map(v3 => $RWSResult(v3._1, v2._2(v3._2), dictMonoid.Semigroup0().append($0)(v3._3)))(v1(r)(v2._1));
+      }),
+      Functor0: () => functorRWST1
+    }
+  );
+};
+const bindRWST = dictBind => {
+  const $0 = dictBind.Apply0().Functor0();
+  const applyRWST1 = applyRWST(dictBind);
+  return dictMonoid => {
+    const applyRWST2 = applyRWST1(dictMonoid);
+    return {
+      bind: v => f => r => s => dictBind.bind(v(r)(s))(v1 => {
+        const $1 = v1._3;
+        return $0.map(v3 => $RWSResult(v3._1, v3._2, dictMonoid.Semigroup0().append($1)(v3._3)))(f(v1._2)(r)(v1._1));
+      }),
+      Apply0: () => applyRWST2
+    };
+  };
+};
+const semigroupRWST = dictBind => {
+  const applyRWST1 = applyRWST(dictBind);
+  return dictMonoid => {
+    const $0 = applyRWST1(dictMonoid);
+    return dictSemigroup => (
+      {
+        append: (() => {
+          const $1 = dictSemigroup.append;
+          return a => b => $0.apply($0.Functor0().map($1)(a))(b);
+        })()
+      }
+    );
+  };
+};
+const applicativeRWST = dictMonad => {
+  const applyRWST1 = applyRWST(dictMonad.Bind1());
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const applyRWST2 = applyRWST1(dictMonoid);
+    return {pure: a => v => s => dictMonad.Applicative0().pure($RWSResult(s, a, mempty)), Apply0: () => applyRWST2};
+  };
+};
+const monadRWST = dictMonad => {
+  const applicativeRWST1 = applicativeRWST(dictMonad);
+  const bindRWST1 = bindRWST(dictMonad.Bind1());
+  return dictMonoid => {
+    const applicativeRWST2 = applicativeRWST1(dictMonoid);
+    const bindRWST2 = bindRWST1(dictMonoid);
+    return {Applicative0: () => applicativeRWST2, Bind1: () => bindRWST2};
+  };
+};
+const monadAskRWST = dictMonad => {
+  const monadRWST1 = monadRWST(dictMonad);
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const monadRWST2 = monadRWST1(dictMonoid);
+    return {ask: r => s => dictMonad.Applicative0().pure($RWSResult(s, r, mempty)), Monad0: () => monadRWST2};
+  };
+};
+const monadReaderRWST = dictMonad => {
+  const monadAskRWST1 = monadAskRWST(dictMonad);
+  return dictMonoid => {
+    const monadAskRWST2 = monadAskRWST1(dictMonoid);
+    return {local: f => m => r => s => m(f(r))(s), MonadAsk0: () => monadAskRWST2};
+  };
+};
+const monadEffectRWS = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return dictMonadEffect => {
+    const Monad0 = dictMonadEffect.Monad0();
+    const monadRWST1 = monadRWST(Monad0)(dictMonoid);
+    return {
+      liftEffect: x => {
+        const $0 = dictMonadEffect.liftEffect(x);
+        return v => s => Monad0.Bind1().bind($0)(a => Monad0.Applicative0().pure($RWSResult(s, a, mempty)));
+      },
+      Monad0: () => monadRWST1
+    };
+  };
+};
+const monadRecRWST = dictMonadRec => {
+  const Monad0 = dictMonadRec.Monad0();
+  const monadRWST1 = monadRWST(Monad0);
+  return dictMonoid => {
+    const $0 = dictMonoid.Semigroup0();
+    const mempty = dictMonoid.mempty;
+    const monadRWST2 = monadRWST1(dictMonoid);
+    return {
+      tailRecM: k => a => r => s => dictMonadRec.tailRecM(v => {
+        const $1 = v._3;
+        return Monad0.Bind1().bind(k(v._2)(r)(v._1))(v2 => Monad0.Applicative0().pure((() => {
+          if (v2._2.tag === "Loop") { return Control$dMonad$dRec$dClass.$Step("Loop", $RWSResult(v2._1, v2._2._1, $0.append($1)(v2._3))); }
+          if (v2._2.tag === "Done") { return Control$dMonad$dRec$dClass.$Step("Done", $RWSResult(v2._1, v2._2._1, $0.append($1)(v2._3))); }
+          $runtime.fail();
+        })()));
+      })($RWSResult(s, a, mempty)),
+      Monad0: () => monadRWST2
+    };
+  };
+};
+const monadStateRWST = dictMonad => {
+  const monadRWST1 = monadRWST(dictMonad);
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const monadRWST2 = monadRWST1(dictMonoid);
+    return {
+      state: f => v => s => {
+        const v1 = f(s);
+        return dictMonad.Applicative0().pure($RWSResult(v1._2, v1._1, mempty));
+      },
+      Monad0: () => monadRWST2
+    };
+  };
+};
+const monadTellRWST = dictMonad => {
+  const monadRWST1 = monadRWST(dictMonad);
+  return dictMonoid => {
+    const Semigroup0 = dictMonoid.Semigroup0();
+    const monadRWST2 = monadRWST1(dictMonoid);
+    return {tell: w => v => s => dictMonad.Applicative0().pure($RWSResult(s, undefined, w)), Semigroup0: () => Semigroup0, Monad1: () => monadRWST2};
+  };
+};
+const monadWriterRWST = dictMonad => {
+  const $0 = dictMonad.Bind1();
+  const $1 = dictMonad.Applicative0();
+  const monadTellRWST1 = monadTellRWST(dictMonad);
+  return dictMonoid => {
+    const monadTellRWST2 = monadTellRWST1(dictMonoid);
+    return {
+      listen: m => r => s => $0.bind(m(r)(s))(v => $1.pure($RWSResult(v._1, Data$dTuple.$Tuple(v._2, v._3), v._3))),
+      pass: m => r => s => $0.bind(m(r)(s))(v => $1.pure($RWSResult(v._1, v._2._1, v._2._2(v._3)))),
+      Monoid0: () => dictMonoid,
+      MonadTell1: () => monadTellRWST2
+    };
+  };
+};
+const monadThrowRWST = dictMonadThrow => {
+  const Monad0 = dictMonadThrow.Monad0();
+  const monadRWST1 = monadRWST(Monad0);
+  return dictMonoid => {
+    const mempty = dictMonoid.mempty;
+    const monadRWST2 = monadRWST1(dictMonoid);
+    return {
+      throwError: e => {
+        const $0 = dictMonadThrow.throwError(e);
+        return v => s => Monad0.Bind1().bind($0)(a => Monad0.Applicative0().pure($RWSResult(s, a, mempty)));
+      },
+      Monad0: () => monadRWST2
+    };
+  };
+};
+const monadErrorRWST = dictMonadError => {
+  const monadThrowRWST1 = monadThrowRWST(dictMonadError.MonadThrow0());
+  return dictMonoid => {
+    const monadThrowRWST2 = monadThrowRWST1(dictMonoid);
+    return {catchError: m => h => r => s => dictMonadError.catchError(m(r)(s))(e => h(e)(r)(s)), MonadThrow0: () => monadThrowRWST2};
+  };
+};
+const monoidRWST = dictMonad => {
+  const applicativeRWST1 = applicativeRWST(dictMonad);
+  const semigroupRWST1 = semigroupRWST(dictMonad.Bind1());
+  return dictMonoid => {
+    const semigroupRWST2 = semigroupRWST1(dictMonoid);
+    return dictMonoid1 => {
+      const semigroupRWST3 = semigroupRWST2(dictMonoid1.Semigroup0());
+      return {mempty: applicativeRWST1(dictMonoid).pure(dictMonoid1.mempty), Semigroup0: () => semigroupRWST3};
+    };
+  };
+};
+const altRWST = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  const functorRWST1 = {map: f => v => r => s => $0.map(v1 => $RWSResult(v1._1, f(v1._2), v1._3))(v(r)(s))};
+  return {alt: v => v1 => r => s => dictAlt.alt(v(r)(s))(v1(r)(s)), Functor0: () => functorRWST1};
+};
+const plusRWST = dictPlus => {
+  const empty = dictPlus.empty;
+  const $0 = dictPlus.Alt0();
+  const $1 = $0.Functor0();
+  const altRWST1 = (() => {
+    const functorRWST1 = {map: f => v => r => s => $1.map(v1 => $RWSResult(v1._1, f(v1._2), v1._3))(v(r)(s))};
+    return {alt: v => v1 => r => s => $0.alt(v(r)(s))(v1(r)(s)), Functor0: () => functorRWST1};
+  })();
+  return {empty: v => v1 => empty, Alt0: () => altRWST1};
+};
+const alternativeRWST = dictMonoid => dictAlternative => {
+  const $0 = dictAlternative.Plus1();
+  const empty = $0.empty;
+  const plusRWST1 = (() => {
+    const $1 = $0.Alt0();
+    const $2 = $1.Functor0();
+    const functorRWST1 = {map: f => v => r => s => $2.map(v1 => $RWSResult(v1._1, f(v1._2), v1._3))(v(r)(s))};
+    const altRWST1 = {alt: v => v1 => r => s => $1.alt(v(r)(s))(v1(r)(s)), Functor0: () => functorRWST1};
+    return {empty: v => v1 => empty, Alt0: () => altRWST1};
+  })();
+  return dictMonad => {
+    const applicativeRWST1 = applicativeRWST(dictMonad)(dictMonoid);
+    return {Applicative0: () => applicativeRWST1, Plus1: () => plusRWST1};
+  };
+};
+export {
+  $RWSResult,
+  RWSResult,
+  RWST,
+  altRWST,
+  alternativeRWST,
+  applicativeRWST,
+  applyRWST,
+  bindRWST,
+  evalRWST,
+  execRWST,
+  functorRWST,
+  lazyRWST,
+  mapRWST,
+  monadAskRWST,
+  monadEffectRWS,
+  monadErrorRWST,
+  monadRWST,
+  monadReaderRWST,
+  monadRecRWST,
+  monadStateRWST,
+  monadTellRWST,
+  monadThrowRWST,
+  monadTransRWST,
+  monadWriterRWST,
+  monoidRWST,
+  newtypeRWST,
+  plusRWST,
+  runRWST,
+  semigroupRWST,
+  withRWST
+};

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

@@ -0,0 +1,6 @@
+// | This module defines the `Reader` monad.
+import * as Control$dMonad$dReader$dTrans from "../Control.Monad.Reader.Trans/index.js";
+const withReader = Control$dMonad$dReader$dTrans.withReaderT;
+const runReader = v => x => v(x);
+const mapReader = f => v => x => f(v(x));
+export {mapReader, runReader, withReader};

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

@@ -0,0 +1,11 @@
+// | This module defines the `MonadReader` type class and its instances.
+import * as Control$dMonad from "../Control.Monad/index.js";
+const monadAskFun = {ask: x => x, Monad0: () => Control$dMonad.monadFn};
+const monadReaderFun = {local: f => g => x => g(f(x)), MonadAsk0: () => monadAskFun};
+const local = dict => dict.local;
+const ask = dict => dict.ask;
+const asks = dictMonadAsk => {
+  const ask1 = dictMonadAsk.ask;
+  return f => dictMonadAsk.Monad0().Bind1().Apply0().Functor0().map(f)(ask1);
+};
+export {ask, asks, local, monadAskFun, monadReaderFun};