@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,320 @@
+// | This module defines the reader monad transformer, `ReaderT`.
+const ReaderT = x => x;
+const withReaderT = f => v => x => v(f(x));
+const runReaderT = v => v;
+const newtypeReaderT = {Coercible0: () => {}};
+const monadTransReaderT = {lift: dictMonad => x => v => x};
+const mapReaderT = f => v => x => f(v(x));
+const functorReaderT = dictFunctor => (
+  {
+    map: x => {
+      const $0 = dictFunctor.map(x);
+      return v => x$1 => $0(v(x$1));
+    }
+  }
+);
+const distributiveReaderT = dictDistributive => {
+  const $0 = dictDistributive.Functor0();
+  const functorReaderT1 = {
+    map: x => {
+      const $1 = $0.map(x);
+      return v => x$1 => $1(v(x$1));
+    }
+  };
+  return {
+    distribute: dictFunctor => {
+      const collect1 = dictDistributive.collect(dictFunctor);
+      return a => e => collect1(r => r(e))(a);
+    },
+    collect: dictFunctor => f => {
+      const $1 = distributiveReaderT(dictDistributive).distribute(dictFunctor);
+      const $2 = dictFunctor.map(f);
+      return x => $1($2(x));
+    },
+    Functor0: () => functorReaderT1
+  };
+};
+const applyReaderT = dictApply => {
+  const $0 = dictApply.Functor0();
+  const functorReaderT1 = {
+    map: x => {
+      const $1 = $0.map(x);
+      return v => x$1 => $1(v(x$1));
+    }
+  };
+  return {apply: v => v1 => r => dictApply.apply(v(r))(v1(r)), Functor0: () => functorReaderT1};
+};
+const bindReaderT = dictBind => {
+  const $0 = dictBind.Apply0();
+  const $1 = $0.Functor0();
+  const applyReaderT1 = (() => {
+    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};
+  })();
+  return {bind: v => k => r => dictBind.bind(v(r))(a => k(a)(r)), Apply0: () => applyReaderT1};
+};
+const semigroupReaderT = dictApply => {
+  const $0 = dictApply.Functor0();
+  return dictSemigroup => (
+    {
+      append: (() => {
+        const $1 = dictSemigroup.append;
+        return a => b => {
+          const $2 = $0.map($1);
+          return r => dictApply.apply($2(a(r)))(b(r));
+        };
+      })()
+    }
+  );
+};
+const applicativeReaderT = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const $1 = $0.Functor0();
+  const functorReaderT1 = {
+    map: x => {
+      const $2 = $1.map(x);
+      return v => x$1 => $2(v(x$1));
+    }
+  };
+  const applyReaderT1 = {apply: v => v1 => r => $0.apply(v(r))(v1(r)), Functor0: () => functorReaderT1};
+  return {
+    pure: x => {
+      const $2 = dictApplicative.pure(x);
+      return v => $2;
+    },
+    Apply0: () => applyReaderT1
+  };
+};
+const monadReaderT = dictMonad => {
+  const $0 = dictMonad.Applicative0();
+  const $1 = $0.Apply0();
+  const applicativeReaderT1 = (() => {
+    const $2 = $1.Functor0();
+    const functorReaderT1 = {
+      map: x => {
+        const $3 = $2.map(x);
+        return v => x$1 => $3(v(x$1));
+      }
+    };
+    const applyReaderT1 = {apply: v => v1 => r => $1.apply(v(r))(v1(r)), Functor0: () => functorReaderT1};
+    return {
+      pure: x => {
+        const $3 = $0.pure(x);
+        return v => $3;
+      },
+      Apply0: () => applyReaderT1
+    };
+  })();
+  const bindReaderT1 = bindReaderT(dictMonad.Bind1());
+  return {Applicative0: () => applicativeReaderT1, Bind1: () => bindReaderT1};
+};
+const monadAskReaderT = dictMonad => {
+  const monadReaderT1 = monadReaderT(dictMonad);
+  return {ask: dictMonad.Applicative0().pure, Monad0: () => monadReaderT1};
+};
+const monadReaderReaderT = dictMonad => {
+  const monadReaderT1 = monadReaderT(dictMonad);
+  const monadAskReaderT1 = {ask: dictMonad.Applicative0().pure, Monad0: () => monadReaderT1};
+  return {local: withReaderT, MonadAsk0: () => monadAskReaderT1};
+};
+const monadContReaderT = dictMonadCont => {
+  const monadReaderT1 = monadReaderT(dictMonadCont.Monad0());
+  return {
+    callCC: f => r => dictMonadCont.callCC(c => f(x => {
+      const $0 = c(x);
+      return v => $0;
+    })(r)),
+    Monad0: () => monadReaderT1
+  };
+};
+const monadEffectReader = dictMonadEffect => {
+  const monadReaderT1 = monadReaderT(dictMonadEffect.Monad0());
+  return {
+    liftEffect: x => {
+      const $0 = dictMonadEffect.liftEffect(x);
+      return v => $0;
+    },
+    Monad0: () => monadReaderT1
+  };
+};
+const monadRecReaderT = dictMonadRec => {
+  const Monad0 = dictMonadRec.Monad0();
+  const $0 = Monad0.Bind1();
+  const pure = Monad0.Applicative0().pure;
+  const monadReaderT1 = monadReaderT(Monad0);
+  return {tailRecM: k => a => r => dictMonadRec.tailRecM(a$p => $0.bind(k(a$p)(r))(pure))(a), Monad0: () => monadReaderT1};
+};
+const monadStateReaderT = dictMonadState => {
+  const monadReaderT1 = monadReaderT(dictMonadState.Monad0());
+  return {
+    state: x => {
+      const $0 = dictMonadState.state(x);
+      return v => $0;
+    },
+    Monad0: () => monadReaderT1
+  };
+};
+const monadTellReaderT = dictMonadTell => {
+  const Semigroup0 = dictMonadTell.Semigroup0();
+  const monadReaderT1 = monadReaderT(dictMonadTell.Monad1());
+  return {
+    tell: x => {
+      const $0 = dictMonadTell.tell(x);
+      return v => $0;
+    },
+    Semigroup0: () => Semigroup0,
+    Monad1: () => monadReaderT1
+  };
+};
+const monadWriterReaderT = dictMonadWriter => {
+  const Monoid0 = dictMonadWriter.Monoid0();
+  const monadTellReaderT1 = monadTellReaderT(dictMonadWriter.MonadTell1());
+  return {listen: v => x => dictMonadWriter.listen(v(x)), pass: v => x => dictMonadWriter.pass(v(x)), Monoid0: () => Monoid0, MonadTell1: () => monadTellReaderT1};
+};
+const monadThrowReaderT = dictMonadThrow => {
+  const monadReaderT1 = monadReaderT(dictMonadThrow.Monad0());
+  return {
+    throwError: x => {
+      const $0 = dictMonadThrow.throwError(x);
+      return v => $0;
+    },
+    Monad0: () => monadReaderT1
+  };
+};
+const monadErrorReaderT = dictMonadError => {
+  const monadThrowReaderT1 = monadThrowReaderT(dictMonadError.MonadThrow0());
+  return {catchError: v => h => r => dictMonadError.catchError(v(r))(e => h(e)(r)), MonadThrow0: () => monadThrowReaderT1};
+};
+const monoidReaderT = dictApplicative => {
+  const $0 = dictApplicative.Apply0();
+  const $1 = $0.Functor0();
+  return dictMonoid => {
+    const semigroupReaderT2 = {
+      append: (() => {
+        const $2 = dictMonoid.Semigroup0().append;
+        return a => b => {
+          const $3 = $1.map($2);
+          return r => $0.apply($3(a(r)))(b(r));
+        };
+      })()
+    };
+    return {
+      mempty: (() => {
+        const $2 = dictApplicative.pure(dictMonoid.mempty);
+        return v => $2;
+      })(),
+      Semigroup0: () => semigroupReaderT2
+    };
+  };
+};
+const altReaderT = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  const functorReaderT1 = {
+    map: x => {
+      const $1 = $0.map(x);
+      return v => x$1 => $1(v(x$1));
+    }
+  };
+  return {alt: v => v1 => r => dictAlt.alt(v(r))(v1(r)), Functor0: () => functorReaderT1};
+};
+const plusReaderT = dictPlus => {
+  const $0 = dictPlus.Alt0();
+  const $1 = $0.Functor0();
+  const altReaderT1 = (() => {
+    const functorReaderT1 = {
+      map: x => {
+        const $2 = $1.map(x);
+        return v => x$1 => $2(v(x$1));
+      }
+    };
+    return {alt: v => v1 => r => $0.alt(v(r))(v1(r)), Functor0: () => functorReaderT1};
+  })();
+  return {
+    empty: (() => {
+      const $2 = dictPlus.empty;
+      return v => $2;
+    })(),
+    Alt0: () => altReaderT1
+  };
+};
+const alternativeReaderT = dictAlternative => {
+  const $0 = dictAlternative.Applicative0();
+  const $1 = $0.Apply0();
+  const applicativeReaderT1 = (() => {
+    const $2 = $1.Functor0();
+    const functorReaderT1 = {
+      map: x => {
+        const $3 = $2.map(x);
+        return v => x$1 => $3(v(x$1));
+      }
+    };
+    const applyReaderT1 = {apply: v => v1 => r => $1.apply(v(r))(v1(r)), Functor0: () => functorReaderT1};
+    return {
+      pure: x => {
+        const $3 = $0.pure(x);
+        return v => $3;
+      },
+      Apply0: () => applyReaderT1
+    };
+  })();
+  const $2 = dictAlternative.Plus1();
+  const $3 = $2.Alt0();
+  const plusReaderT1 = (() => {
+    const $4 = $3.Functor0();
+    const functorReaderT1 = {
+      map: x => {
+        const $5 = $4.map(x);
+        return v => x$1 => $5(v(x$1));
+      }
+    };
+    const altReaderT1 = {alt: v => v1 => r => $3.alt(v(r))(v1(r)), Functor0: () => functorReaderT1};
+    return {
+      empty: (() => {
+        const $5 = $2.empty;
+        return v => $5;
+      })(),
+      Alt0: () => altReaderT1
+    };
+  })();
+  return {Applicative0: () => applicativeReaderT1, Plus1: () => plusReaderT1};
+};
+const monadPlusReaderT = dictMonadPlus => {
+  const monadReaderT1 = monadReaderT(dictMonadPlus.Monad0());
+  const alternativeReaderT1 = alternativeReaderT(dictMonadPlus.Alternative1());
+  return {Monad0: () => monadReaderT1, Alternative1: () => alternativeReaderT1};
+};
+export {
+  ReaderT,
+  altReaderT,
+  alternativeReaderT,
+  applicativeReaderT,
+  applyReaderT,
+  bindReaderT,
+  distributiveReaderT,
+  functorReaderT,
+  mapReaderT,
+  monadAskReaderT,
+  monadContReaderT,
+  monadEffectReader,
+  monadErrorReaderT,
+  monadPlusReaderT,
+  monadReaderReaderT,
+  monadReaderT,
+  monadRecReaderT,
+  monadStateReaderT,
+  monadTellReaderT,
+  monadThrowReaderT,
+  monadTransReaderT,
+  monadWriterReaderT,
+  monoidReaderT,
+  newtypeReaderT,
+  plusReaderT,
+  runReaderT,
+  semigroupReaderT,
+  withReaderT
+};

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

@@ -0,0 +1,265 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad from "../Control.Monad/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Effect from "../Effect/index.js";
+const $Step = (tag, _1) => ({tag, _1});
+const Loop = value0 => $Step("Loop", value0);
+const Done = value0 => $Step("Done", value0);
+const tailRecM = dict => dict.tailRecM;
+const tailRecM2 = dictMonadRec => f => a => b => dictMonadRec.tailRecM(o => f(o.a)(o.b))({a, b});
+const tailRecM3 = dictMonadRec => f => a => b => c => dictMonadRec.tailRecM(o => f(o.a)(o.b)(o.c))({a, b, c});
+const untilJust = dictMonadRec => {
+  const $0 = dictMonadRec.Monad0().Bind1().Apply0().Functor0();
+  return m => dictMonadRec.tailRecM(v => $0.map(v1 => {
+    if (v1.tag === "Nothing") { return $Step("Loop", undefined); }
+    if (v1.tag === "Just") { return $Step("Done", v1._1); }
+    $runtime.fail();
+  })(m))();
+};
+const whileJust = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return dictMonadRec => {
+    const $0 = dictMonadRec.Monad0().Bind1().Apply0().Functor0();
+    return m => dictMonadRec.tailRecM(v => $0.map(v1 => {
+      if (v1.tag === "Nothing") { return $Step("Done", v); }
+      if (v1.tag === "Just") { return $Step("Loop", dictMonoid.Semigroup0().append(v)(v1._1)); }
+      $runtime.fail();
+    })(m))(mempty);
+  };
+};
+const tailRec = f => {
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0;
+      if (v.tag === "Loop") {
+        go$a0 = f(v._1);
+        continue;
+      }
+      if (v.tag === "Done") {
+        go$c = false;
+        go$r = v._1;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return x => go(f(x));
+};
+const tailRec2 = f => a => b => {
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0;
+      if (v.tag === "Loop") {
+        go$a0 = f(v._1.a)(v._1.b);
+        continue;
+      }
+      if (v.tag === "Done") {
+        go$c = false;
+        go$r = v._1;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(f(a)(b));
+};
+const tailRec3 = f => a => b => c => {
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0;
+      if (v.tag === "Loop") {
+        go$a0 = f(v._1.a)(v._1.b)(v._1.c);
+        continue;
+      }
+      if (v.tag === "Done") {
+        go$c = false;
+        go$r = v._1;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(f(a)(b)(c));
+};
+const monadRecMaybe = {
+  tailRecM: f => a0 => {
+    const $0 = v => {
+      if (v.tag === "Nothing") { return $Step("Done", Data$dMaybe.Nothing); }
+      if (v.tag === "Just") {
+        if (v._1.tag === "Loop") { return $Step("Loop", f(v._1._1)); }
+        if (v._1.tag === "Done") { return $Step("Done", Data$dMaybe.$Maybe("Just", v._1._1)); }
+      }
+      $runtime.fail();
+    };
+    const go = go$a0$copy => {
+      let go$a0 = go$a0$copy, go$c = true, go$r;
+      while (go$c) {
+        const v = go$a0;
+        if (v.tag === "Loop") {
+          go$a0 = $0(v._1);
+          continue;
+        }
+        if (v.tag === "Done") {
+          go$c = false;
+          go$r = v._1;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go($0(f(a0)));
+  },
+  Monad0: () => Data$dMaybe.monadMaybe
+};
+const monadRecIdentity = {
+  tailRecM: f => {
+    const go = go$a0$copy => {
+      let go$a0 = go$a0$copy, go$c = true, go$r;
+      while (go$c) {
+        const v = go$a0;
+        if (v.tag === "Loop") {
+          go$a0 = f(v._1);
+          continue;
+        }
+        if (v.tag === "Done") {
+          go$c = false;
+          go$r = v._1;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return x => go(f(x));
+  },
+  Monad0: () => Data$dIdentity.monadIdentity
+};
+const monadRecFunction = {
+  tailRecM: f => a0 => e => {
+    const go = go$a0$copy => {
+      let go$a0 = go$a0$copy, go$c = true, go$r;
+      while (go$c) {
+        const v = go$a0;
+        if (v.tag === "Loop") {
+          go$a0 = f(v._1)(e);
+          continue;
+        }
+        if (v.tag === "Done") {
+          go$c = false;
+          go$r = v._1;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go(f(a0)(e));
+  },
+  Monad0: () => Control$dMonad.monadFn
+};
+const monadRecEither = {
+  tailRecM: f => a0 => {
+    const $0 = v => {
+      if (v.tag === "Left") { return $Step("Done", Data$dEither.$Either("Left", v._1)); }
+      if (v.tag === "Right") {
+        if (v._1.tag === "Loop") { return $Step("Loop", f(v._1._1)); }
+        if (v._1.tag === "Done") { return $Step("Done", Data$dEither.$Either("Right", v._1._1)); }
+      }
+      $runtime.fail();
+    };
+    const go = go$a0$copy => {
+      let go$a0 = go$a0$copy, go$c = true, go$r;
+      while (go$c) {
+        const v = go$a0;
+        if (v.tag === "Loop") {
+          go$a0 = $0(v._1);
+          continue;
+        }
+        if (v.tag === "Done") {
+          go$c = false;
+          go$r = v._1;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go($0(f(a0)));
+  },
+  Monad0: () => Data$dEither.monadEither
+};
+const monadRecEffect = {
+  tailRecM: f => a => {
+    const $0 = f(a);
+    return () => {
+      const $1 = $0();
+      let r = $1;
+      Effect.untilE(() => {
+        const v = r;
+        if (v.tag === "Loop") {
+          const e = f(v._1)();
+          r = e;
+          return false;
+        }
+        if (v.tag === "Done") { return true; }
+        $runtime.fail();
+      })();
+      const a$p = r;
+      if (a$p.tag === "Done") { return a$p._1; }
+      $runtime.fail();
+    };
+  },
+  Monad0: () => Effect.monadEffect
+};
+const loop3 = a => b => c => $Step("Loop", {a, b, c});
+const loop2 = a => b => $Step("Loop", {a, b});
+const functorStep = {
+  map: f => m => {
+    if (m.tag === "Loop") { return $Step("Loop", m._1); }
+    if (m.tag === "Done") { return $Step("Done", f(m._1)); }
+    $runtime.fail();
+  }
+};
+const forever = dictMonadRec => {
+  const $0 = dictMonadRec.Monad0().Bind1().Apply0().Functor0();
+  return ma => dictMonadRec.tailRecM(u => $0.map(v => $Step("Loop", u))(ma))();
+};
+const bifunctorStep = {
+  bimap: v => v1 => v2 => {
+    if (v2.tag === "Loop") { return $Step("Loop", v(v2._1)); }
+    if (v2.tag === "Done") { return $Step("Done", v1(v2._1)); }
+    $runtime.fail();
+  }
+};
+export {
+  $Step,
+  Done,
+  Loop,
+  bifunctorStep,
+  forever,
+  functorStep,
+  loop2,
+  loop3,
+  monadRecEffect,
+  monadRecEither,
+  monadRecFunction,
+  monadRecIdentity,
+  monadRecMaybe,
+  tailRec,
+  tailRec2,
+  tailRec3,
+  tailRecM,
+  tailRecM2,
+  tailRecM3,
+  untilJust,
+  whileJust
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,7 @@
+import * as Control$dMonad$dST$dInternal from "../Control.Monad.ST.Internal/index.js";
+import * as Effect from "../Effect/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const monadSTST = {liftST: x => x, Monad0: () => Control$dMonad$dST$dInternal.monadST};
+const monadSTEffect = {liftST: Unsafe$dCoerce.unsafeCoerce, Monad0: () => Effect.monadEffect};
+const liftST = dict => dict.liftST;
+export {liftST, monadSTEffect, monadSTST};

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

@@ -0,0 +1,3 @@
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const toEffect = Unsafe$dCoerce.unsafeCoerce;
+export {toEffect};

package/output-es/Control.Monad.ST.Internal/foreign.js

@@ -0,0 +1,90 @@
+export const map_ = function (f) {
+  return function (a) {
+    return function () {
+      return f(a());
+    };
+  };
+};
+
+export const pure_ = function (a) {
+  return function () {
+    return a;
+  };
+};
+
+export const bind_ = function (a) {
+  return function (f) {
+    return function () {
+      return f(a())();
+    };
+  };
+};
+
+export const run = function (f) {
+  return f();
+};
+
+function whileST(f) {
+  return function (a) {
+    return function () {
+      while (f()) {
+        a();
+      }
+    };
+  };
+}
+export { whileST as while };
+
+function forST(lo) {
+  return function (hi) {
+    return function (f) {
+      return function () {
+        for (var i = lo; i < hi; i++) {
+          f(i)();
+        }
+      };
+    };
+  };
+}
+export { forST as for };
+
+export const foreach = function (as) {
+  return function (f) {
+    return function () {
+      for (var i = 0, l = as.length; i < l; i++) {
+        f(as[i])();
+      }
+    };
+  };
+};
+
+function newSTRef(val) {
+  return function () {
+    return { value: val };
+  };
+}
+export { newSTRef as new };
+
+export const read = function (ref) {
+  return function () {
+    return ref.value;
+  };
+};
+
+export const modifyImpl = function (f) {
+  return function (ref) {
+    return function () {
+      var t = f(ref.value);
+      ref.value = t.state;
+      return t.value;
+    };
+  };
+};
+
+export const write = function (a) {
+  return function (ref) {
+    return function () {
+      return ref.value = a; // eslint-disable-line no-return-assign
+    };
+  };
+};