@explorable-viz/fluid 0.12.2 → 0.12.4

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

@@ -0,0 +1,75 @@
+import * as $runtime from "../runtime.js";
+import {for as $$for, new as $$new, while as $$while, bind_, foreach, map_, modifyImpl, pure_, read, run, write} from "./foreign.js";
+const modify$p = modifyImpl;
+const modify = f => modifyImpl(s => {
+  const s$p = f(s);
+  return {state: s$p, value: s$p};
+});
+const functorST = {map: map_};
+const monadST = {Applicative0: () => applicativeST, Bind1: () => bindST};
+const bindST = {bind: bind_, Apply0: () => applyST};
+const applyST = {
+  apply: f => a => () => {
+    const f$p = f();
+    const a$p = a();
+    return applicativeST.pure(f$p(a$p))();
+  },
+  Functor0: () => functorST
+};
+const applicativeST = {pure: pure_, Apply0: () => applyST};
+const semigroupST = dictSemigroup => (
+  {
+    append: a => b => () => {
+      const $0 = a();
+      const a$p = b();
+      return dictSemigroup.append($0)(a$p);
+    }
+  }
+);
+const monadRecST = {
+  tailRecM: f => a => {
+    const $0 = f(a);
+    return () => {
+      const $1 = $0();
+      let r = $1;
+      while (
+        (() => {
+          const $2 = r;
+          return $2.tag === "Loop";
+        })()
+      ) {
+        const v = r;
+        if (v.tag === "Loop") {
+          const e = f(v._1)();
+          r = e;
+          continue;
+        }
+        if (v.tag === "Done") { continue; }
+        $runtime.fail();
+      }
+      const $2 = r;
+      if ($2.tag === "Done") { return $2._1; }
+      $runtime.fail();
+    };
+  },
+  Monad0: () => monadST
+};
+const monoidST = dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const semigroupST1 = {
+    append: a => b => () => {
+      const $1 = a();
+      const a$p = b();
+      return $0.append($1)(a$p);
+    }
+  };
+  return {
+    mempty: (() => {
+      const $1 = dictMonoid.mempty;
+      return () => $1;
+    })(),
+    Semigroup0: () => semigroupST1
+  };
+};
+export {applicativeST, applyST, bindST, functorST, modify, modify$p, monadRecST, monadST, monoidST, semigroupST};
+export * from "./foreign.js";

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

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

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

@@ -0,0 +1,229 @@
+export const mkSTFn1 = function mkSTFn1(fn) {
+  return function(x) {
+    return fn(x)();
+  };
+};
+  
+export const mkSTFn2 = function mkSTFn2(fn) {
+  return function(a, b) {
+    return fn(a)(b)();
+  };
+};
+  
+export const mkSTFn3 = function mkSTFn3(fn) {
+  return function(a, b, c) {
+    return fn(a)(b)(c)();
+  };
+};
+  
+export const mkSTFn4 = function mkSTFn4(fn) {
+  return function(a, b, c, d) {
+    return fn(a)(b)(c)(d)();
+  };
+};
+  
+export const mkSTFn5 = function mkSTFn5(fn) {
+  return function(a, b, c, d, e) {
+    return fn(a)(b)(c)(d)(e)();
+  };
+};
+  
+export const mkSTFn6 = function mkSTFn6(fn) {
+  return function(a, b, c, d, e, f) {
+    return fn(a)(b)(c)(d)(e)(f)();
+  };
+};
+  
+export const mkSTFn7 = function mkSTFn7(fn) {
+  return function(a, b, c, d, e, f, g) {
+    return fn(a)(b)(c)(d)(e)(f)(g)();
+  };
+};
+  
+export const mkSTFn8 = function mkSTFn8(fn) {
+  return function(a, b, c, d, e, f, g, h) {
+    return fn(a)(b)(c)(d)(e)(f)(g)(h)();
+  };
+};
+  
+export const mkSTFn9 = function mkSTFn9(fn) {
+  return function(a, b, c, d, e, f, g, h, i) {
+    return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)();
+  };
+};
+  
+export const mkSTFn10 = function mkSTFn10(fn) {
+  return function(a, b, c, d, e, f, g, h, i, j) {
+    return fn(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)();
+  };
+};
+  
+export const runSTFn1 = function runSTFn1(fn) {
+  return function(a) {
+    return function() {
+      return fn(a);
+    };
+  };
+};
+  
+export const runSTFn2 = function runSTFn2(fn) {
+  return function(a) {
+    return function(b) {
+      return function() {
+        return fn(a, b);
+      };
+    };
+  };
+};
+  
+export const runSTFn3 = function runSTFn3(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function() {
+          return fn(a, b, c);
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn4 = function runSTFn4(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function() {
+            return fn(a, b, c, d);
+          };
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn5 = function runSTFn5(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function(e) {
+            return function() {
+              return fn(a, b, c, d, e);
+            };
+          };
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn6 = function runSTFn6(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function(e) {
+            return function(f) {
+              return function() {
+                return fn(a, b, c, d, e, f);
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn7 = function runSTFn7(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function(e) {
+            return function(f) {
+              return function(g) {
+                return function() {
+                  return fn(a, b, c, d, e, f, g);
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn8 = function runSTFn8(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function(e) {
+            return function(f) {
+              return function(g) {
+                return function(h) {
+                  return function() {
+                    return fn(a, b, c, d, e, f, g, h);
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn9 = function runSTFn9(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function(e) {
+            return function(f) {
+              return function(g) {
+                return function(h) {
+                  return function(i) {
+                    return function() {
+                      return fn(a, b, c, d, e, f, g, h, i);
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};
+  
+export const runSTFn10 = function runSTFn10(fn) {
+  return function(a) {
+    return function(b) {
+      return function(c) {
+        return function(d) {
+          return function(e) {
+            return function(f) {
+              return function(g) {
+                return function(h) {
+                  return function(i) {
+                    return function(j) {
+                      return function() {
+                        return fn(a, b, c, d, e, f, g, h, i, j);
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+};

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

@@ -0,0 +1,39 @@
+// | This module defines types for STf uncurried functions, as well as
+// | functions for converting back and forth between them.
+// |
+// | The general naming scheme for functions and types in this module is as
+// | follows:
+// |
+// | * `STFn{N}` means, an uncurried function which accepts N arguments and
+// |   performs some STs. The first N arguments are the actual function's
+// |   argument. The last type argument is the return type.
+// | * `runSTFn{N}` takes an `STFn` of N arguments, and converts it into
+// |   the normal PureScript form: a curried function which returns an ST
+// |   action.
+// | * `mkSTFn{N}` is the inverse of `runSTFn{N}`. It can be useful for
+// |   callbacks.
+// |
+import {
+  mkSTFn1,
+  mkSTFn10,
+  mkSTFn2,
+  mkSTFn3,
+  mkSTFn4,
+  mkSTFn5,
+  mkSTFn6,
+  mkSTFn7,
+  mkSTFn8,
+  mkSTFn9,
+  runSTFn1,
+  runSTFn10,
+  runSTFn2,
+  runSTFn3,
+  runSTFn4,
+  runSTFn5,
+  runSTFn6,
+  runSTFn7,
+  runSTFn8,
+  runSTFn9
+} from "./foreign.js";
+export {};
+export * from "./foreign.js";

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

@@ -0,0 +1,8 @@
+// | This module defines the `State` monad.
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+const withState = Control$dMonad$dState$dTrans.withStateT;
+const runState = v => x => v(x);
+const mapState = f => v => x => f(v(x));
+const execState = v => s => v(s)._2;
+const evalState = v => s => v(s)._1;
+export {evalState, execState, mapState, runState, withState};

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

@@ -0,0 +1,12 @@
+// | This module defines the `MonadState` type class and its instances.
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const state = dict => dict.state;
+const put = dictMonadState => s => dictMonadState.state(v => Data$dTuple.$Tuple(undefined, s));
+const modify_ = dictMonadState => f => dictMonadState.state(s => Data$dTuple.$Tuple(undefined, f(s)));
+const modify = dictMonadState => f => dictMonadState.state(s => {
+  const s$p = f(s);
+  return Data$dTuple.$Tuple(s$p, s$p);
+});
+const gets = dictMonadState => f => dictMonadState.state(s => Data$dTuple.$Tuple(f(s), s));
+const $$get = dictMonadState => dictMonadState.state(s => Data$dTuple.$Tuple(s, s));
+export {$$get as get, gets, modify, modify_, put, state};

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

@@ -0,0 +1,209 @@
+// | This module defines the state monad transformer, `StateT`.
+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 StateT = x => x;
+const withStateT = f => v => x => v(f(x));
+const runStateT = v => v;
+const newtypeStateT = {Coercible0: () => {}};
+const monadTransStateT = {lift: dictMonad => m => s => dictMonad.Bind1().bind(m)(x => dictMonad.Applicative0().pure(Data$dTuple.$Tuple(x, s)))};
+const mapStateT = f => v => x => f(v(x));
+const lazyStateT = {defer: f => s => f()(s)};
+const functorStateT = dictFunctor => ({map: f => v => s => dictFunctor.map(v1 => Data$dTuple.$Tuple(f(v1._1), v1._2))(v(s))});
+const execStateT = dictFunctor => v => s => dictFunctor.map(Data$dTuple.snd)(v(s));
+const evalStateT = dictFunctor => v => s => dictFunctor.map(Data$dTuple.fst)(v(s));
+const monadStateT = dictMonad => ({Applicative0: () => applicativeStateT(dictMonad), Bind1: () => bindStateT(dictMonad)});
+const bindStateT = dictMonad => ({bind: v => f => s => dictMonad.Bind1().bind(v(s))(v1 => f(v1._1)(v1._2)), Apply0: () => applyStateT(dictMonad)});
+const applyStateT = dictMonad => {
+  const $0 = dictMonad.Bind1().Apply0().Functor0();
+  const functorStateT1 = {map: f => v => s => $0.map(v1 => Data$dTuple.$Tuple(f(v1._1), v1._2))(v(s))};
+  return {
+    apply: (() => {
+      const $1 = bindStateT(dictMonad);
+      return f => a => $1.bind(f)(f$p => $1.bind(a)(a$p => applicativeStateT(dictMonad).pure(f$p(a$p))));
+    })(),
+    Functor0: () => functorStateT1
+  };
+};
+const applicativeStateT = dictMonad => ({pure: a => s => dictMonad.Applicative0().pure(Data$dTuple.$Tuple(a, s)), Apply0: () => applyStateT(dictMonad)});
+const semigroupStateT = dictMonad => {
+  const $0 = applyStateT(dictMonad);
+  return dictSemigroup => (
+    {
+      append: (() => {
+        const $1 = dictSemigroup.append;
+        return a => b => $0.apply($0.Functor0().map($1)(a))(b);
+      })()
+    }
+  );
+};
+const monadAskStateT = dictMonadAsk => {
+  const Monad0 = dictMonadAsk.Monad0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0)};
+  return {
+    ask: (() => {
+      const $0 = dictMonadAsk.ask;
+      return s => Monad0.Bind1().bind($0)(x => Monad0.Applicative0().pure(Data$dTuple.$Tuple(x, s)));
+    })(),
+    Monad0: () => monadStateT1
+  };
+};
+const monadReaderStateT = dictMonadReader => {
+  const monadAskStateT1 = monadAskStateT(dictMonadReader.MonadAsk0());
+  return {
+    local: x => {
+      const $0 = dictMonadReader.local(x);
+      return v => x$1 => $0(v(x$1));
+    },
+    MonadAsk0: () => monadAskStateT1
+  };
+};
+const monadContStateT = dictMonadCont => {
+  const $0 = dictMonadCont.Monad0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT($0), Bind1: () => bindStateT($0)};
+  return {callCC: f => s => dictMonadCont.callCC(c => f(a => s$p => c(Data$dTuple.$Tuple(a, s$p)))(s)), Monad0: () => monadStateT1};
+};
+const monadEffectState = dictMonadEffect => {
+  const Monad0 = dictMonadEffect.Monad0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0)};
+  return {
+    liftEffect: x => {
+      const $0 = dictMonadEffect.liftEffect(x);
+      return s => Monad0.Bind1().bind($0)(x$1 => Monad0.Applicative0().pure(Data$dTuple.$Tuple(x$1, s)));
+    },
+    Monad0: () => monadStateT1
+  };
+};
+const monadRecStateT = dictMonadRec => {
+  const Monad0 = dictMonadRec.Monad0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0)};
+  return {
+    tailRecM: f => a => s => dictMonadRec.tailRecM(v => Monad0.Bind1().bind(f(v._1)(v._2))(v2 => Monad0.Applicative0().pure((() => {
+      if (v2._1.tag === "Loop") { return Control$dMonad$dRec$dClass.$Step("Loop", Data$dTuple.$Tuple(v2._1._1, v2._2)); }
+      if (v2._1.tag === "Done") { return Control$dMonad$dRec$dClass.$Step("Done", Data$dTuple.$Tuple(v2._1._1, v2._2)); }
+      $runtime.fail();
+    })())))(Data$dTuple.$Tuple(a, s)),
+    Monad0: () => monadStateT1
+  };
+};
+const monadStateStateT = dictMonad => {
+  const monadStateT1 = {Applicative0: () => applicativeStateT(dictMonad), Bind1: () => bindStateT(dictMonad)};
+  return {state: f => x => dictMonad.Applicative0().pure(f(x)), Monad0: () => monadStateT1};
+};
+const monadTellStateT = dictMonadTell => {
+  const Monad1 = dictMonadTell.Monad1();
+  const Semigroup0 = dictMonadTell.Semigroup0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT(Monad1), Bind1: () => bindStateT(Monad1)};
+  return {
+    tell: x => {
+      const $0 = dictMonadTell.tell(x);
+      return s => Monad1.Bind1().bind($0)(x$1 => Monad1.Applicative0().pure(Data$dTuple.$Tuple(x$1, s)));
+    },
+    Semigroup0: () => Semigroup0,
+    Monad1: () => monadStateT1
+  };
+};
+const monadWriterStateT = dictMonadWriter => {
+  const MonadTell1 = dictMonadWriter.MonadTell1();
+  const Monad1 = MonadTell1.Monad1();
+  const $0 = Monad1.Bind1();
+  const $1 = Monad1.Applicative0();
+  const Monoid0 = dictMonadWriter.Monoid0();
+  const monadTellStateT1 = monadTellStateT(MonadTell1);
+  return {
+    listen: m => s => $0.bind(dictMonadWriter.listen(m(s)))(v => $1.pure(Data$dTuple.$Tuple(Data$dTuple.$Tuple(v._1._1, v._2), v._1._2))),
+    pass: m => s => dictMonadWriter.pass($0.bind(m(s))(v => $1.pure(Data$dTuple.$Tuple(Data$dTuple.$Tuple(v._1._1, v._2), v._1._2)))),
+    Monoid0: () => Monoid0,
+    MonadTell1: () => monadTellStateT1
+  };
+};
+const monadThrowStateT = dictMonadThrow => {
+  const Monad0 = dictMonadThrow.Monad0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0)};
+  return {
+    throwError: e => {
+      const $0 = dictMonadThrow.throwError(e);
+      return s => Monad0.Bind1().bind($0)(x => Monad0.Applicative0().pure(Data$dTuple.$Tuple(x, s)));
+    },
+    Monad0: () => monadStateT1
+  };
+};
+const monadErrorStateT = dictMonadError => {
+  const monadThrowStateT1 = monadThrowStateT(dictMonadError.MonadThrow0());
+  return {catchError: v => h => s => dictMonadError.catchError(v(s))(e => h(e)(s)), MonadThrow0: () => monadThrowStateT1};
+};
+const monoidStateT = dictMonad => {
+  const semigroupStateT1 = semigroupStateT(dictMonad);
+  return dictMonoid => {
+    const semigroupStateT2 = semigroupStateT1(dictMonoid.Semigroup0());
+    return {mempty: applicativeStateT(dictMonad).pure(dictMonoid.mempty), Semigroup0: () => semigroupStateT2};
+  };
+};
+const altStateT = dictMonad => dictAlt => {
+  const $0 = dictAlt.Functor0();
+  const functorStateT1 = {map: f => v => s => $0.map(v1 => Data$dTuple.$Tuple(f(v1._1), v1._2))(v(s))};
+  return {alt: v => v1 => s => dictAlt.alt(v(s))(v1(s)), Functor0: () => functorStateT1};
+};
+const plusStateT = dictMonad => dictPlus => {
+  const empty = dictPlus.empty;
+  const $0 = dictPlus.Alt0();
+  const $1 = $0.Functor0();
+  const altStateT2 = (() => {
+    const functorStateT1 = {map: f => v => s => $1.map(v1 => Data$dTuple.$Tuple(f(v1._1), v1._2))(v(s))};
+    return {alt: v => v1 => s => $0.alt(v(s))(v1(s)), Functor0: () => functorStateT1};
+  })();
+  return {empty: v => empty, Alt0: () => altStateT2};
+};
+const alternativeStateT = dictMonad => {
+  const applicativeStateT1 = applicativeStateT(dictMonad);
+  return dictAlternative => {
+    const $0 = dictAlternative.Plus1();
+    const empty = $0.empty;
+    const plusStateT2 = (() => {
+      const $1 = $0.Alt0();
+      const $2 = $1.Functor0();
+      const functorStateT1 = {map: f => v => s => $2.map(v1 => Data$dTuple.$Tuple(f(v1._1), v1._2))(v(s))};
+      const altStateT2 = {alt: v => v1 => s => $1.alt(v(s))(v1(s)), Functor0: () => functorStateT1};
+      return {empty: v => empty, Alt0: () => altStateT2};
+    })();
+    return {Applicative0: () => applicativeStateT1, Plus1: () => plusStateT2};
+  };
+};
+const monadPlusStateT = dictMonadPlus => {
+  const Monad0 = dictMonadPlus.Monad0();
+  const monadStateT1 = {Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0)};
+  const alternativeStateT1 = alternativeStateT(Monad0)(dictMonadPlus.Alternative1());
+  return {Monad0: () => monadStateT1, Alternative1: () => alternativeStateT1};
+};
+export {
+  StateT,
+  altStateT,
+  alternativeStateT,
+  applicativeStateT,
+  applyStateT,
+  bindStateT,
+  evalStateT,
+  execStateT,
+  functorStateT,
+  lazyStateT,
+  mapStateT,
+  monadAskStateT,
+  monadContStateT,
+  monadEffectState,
+  monadErrorStateT,
+  monadPlusStateT,
+  monadReaderStateT,
+  monadRecStateT,
+  monadStateStateT,
+  monadStateT,
+  monadTellStateT,
+  monadThrowStateT,
+  monadTransStateT,
+  monadWriterStateT,
+  monoidStateT,
+  newtypeStateT,
+  plusStateT,
+  runStateT,
+  semigroupStateT,
+  withStateT
+};

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

@@ -0,0 +1,9 @@
+// | A _trampoline_ monad, which can be used at the bottom of
+// | a monad transformer stack to avoid stack overflows in large
+// | monadic computations.
+import * as Control$dMonad$dFree from "../Control.Monad.Free/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+const runTrampoline = /* #__PURE__ */ Control$dMonad$dFree.runFree(Data$dFunctor.functorFn)(v => v());
+const done = /* #__PURE__ */ (() => Control$dMonad$dFree.freeApplicative.pure)();
+const delay = Control$dMonad$dFree.liftF;
+export {delay, done, runTrampoline};

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

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

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

@@ -0,0 +1,6 @@
+// | This module defines the `Writer` monad.
+const writer = x => x;
+const runWriter = x => x;
+const mapWriter = f => v => f(v);
+const execWriter = m => m._2;
+export {execWriter, mapWriter, runWriter, writer};

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

@@ -0,0 +1,14 @@
+// | This module defines the `MonadWriter` type class and its instances.
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const tell = dict => dict.tell;
+const pass = dict => dict.pass;
+const listen = dict => dict.listen;
+const listens = dictMonadWriter => {
+  const Monad1 = dictMonadWriter.MonadTell1().Monad1();
+  return f => m => Monad1.Bind1().bind(dictMonadWriter.listen(m))(v => Monad1.Applicative0().pure(Data$dTuple.$Tuple(v._1, f(v._2))));
+};
+const censor = dictMonadWriter => {
+  const Monad1 = dictMonadWriter.MonadTell1().Monad1();
+  return f => m => dictMonadWriter.pass(Monad1.Bind1().bind(m)(a => Monad1.Applicative0().pure(Data$dTuple.$Tuple(a, f))));
+};
+export {censor, listen, listens, pass, tell};