@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,45 @@
+import * as Control$dBind from "../Control.Bind/index.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Control$dMonad$dFree from "../Control.Monad.Free/index.js";
+import * as Control$dMonad$dMaybe$dTrans from "../Control.Monad.Maybe.Trans/index.js";
+import * as Control$dMonad$dReader$dTrans from "../Control.Monad.Reader.Trans/index.js";
+import * as Control$dMonad$dState$dTrans from "../Control.Monad.State.Trans/index.js";
+import * as Control$dMonad$dWriter$dTrans from "../Control.Monad.Writer.Trans/index.js";
+import * as Data$dCatList from "../Data.CatList/index.js";
+import * as Data$dCatQueue from "../Data.CatQueue/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+const wrapFree = dict => dict.wrapFree;
+const monadFreeWriterT = dictFunctor => dictMonadFree => {
+  const Monad0 = dictMonadFree.Monad0();
+  return dictMonoid => {
+    const monadWriterT = Control$dMonad$dWriter$dTrans.monadWriterT(dictMonoid)(Monad0);
+    return {wrapFree: f => dictMonadFree.wrapFree(dictFunctor.map(Control$dMonad$dWriter$dTrans.runWriterT)(f)), Monad0: () => monadWriterT};
+  };
+};
+const monadFreeStateT = dictFunctor => dictMonadFree => {
+  const $0 = dictMonadFree.Monad0();
+  const monadStateT = {Applicative0: () => Control$dMonad$dState$dTrans.applicativeStateT($0), Bind1: () => Control$dMonad$dState$dTrans.bindStateT($0)};
+  return {wrapFree: f => s => dictMonadFree.wrapFree(dictFunctor.map(st => st(s))(f)), Monad0: () => monadStateT};
+};
+const monadFreeReaderT = dictFunctor => dictMonadFree => {
+  const monadReaderT = Control$dMonad$dReader$dTrans.monadReaderT(dictMonadFree.Monad0());
+  return {wrapFree: f => r => dictMonadFree.wrapFree(dictFunctor.map(rt => rt(r))(f)), Monad0: () => monadReaderT};
+};
+const monadFreeMaybeT = dictFunctor => dictMonadFree => {
+  const $0 = dictMonadFree.Monad0();
+  const monadMaybeT = {Applicative0: () => Control$dMonad$dMaybe$dTrans.applicativeMaybeT($0), Bind1: () => Control$dMonad$dMaybe$dTrans.bindMaybeT($0)};
+  return {wrapFree: f => dictMonadFree.wrapFree(dictFunctor.map(Control$dMonad$dMaybe$dTrans.runMaybeT)(f)), Monad0: () => monadMaybeT};
+};
+const monadFreeFree = {
+  wrapFree: x => Control$dMonad$dFree.$Free(
+    Control$dMonad$dFree.$FreeView("Bind", x, x$1 => Control$dMonad$dFree.$Free(Control$dMonad$dFree.$FreeView("Return", x$1), Data$dCatList.CatNil)),
+    Data$dCatList.$CatList("CatCons", Control$dBind.identity, Data$dCatQueue.$CatQueue(Data$dList$dTypes.Nil, Data$dList$dTypes.Nil))
+  ),
+  Monad0: () => Control$dMonad$dFree.freeMonad
+};
+const monadFreeExceptT = dictFunctor => dictMonadFree => {
+  const $0 = dictMonadFree.Monad0();
+  const monadExceptT = {Applicative0: () => Control$dMonad$dExcept$dTrans.applicativeExceptT($0), Bind1: () => Control$dMonad$dExcept$dTrans.bindExceptT($0)};
+  return {wrapFree: f => dictMonadFree.wrapFree(dictFunctor.map(Control$dMonad$dExcept$dTrans.runExceptT)(f)), Monad0: () => monadExceptT};
+};
+export {monadFreeExceptT, monadFreeFree, monadFreeMaybeT, monadFreeReaderT, monadFreeStateT, monadFreeWriterT, wrapFree};

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

@@ -0,0 +1,132 @@
+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$dSemigroup$dLast from "../Data.Semigroup.Last/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const $LL = (tag, _1, _2) => ({tag, _1, _2});
+const monoidAdditive = /* #__PURE__ */ (() => {
+  const semigroupAdditive1 = {append: v => v1 => v + v1};
+  return {mempty: 0.0, Semigroup0: () => semigroupAdditive1};
+})();
+const Cons = value0 => value1 => $LL("Cons", value0, value1);
+const Nil = /* #__PURE__ */ $LL("Nil");
+const unfoldable = dictMonadRec => dictMonadGen => {
+  const Monad0 = dictMonadGen.Monad0();
+  const $0 = Monad0.Applicative0();
+  const Bind1 = Monad0.Bind1();
+  return dictUnfoldable => gen => Bind1.Apply0().Functor0().map(dictUnfoldable.unfoldr(v => {
+    if (v.tag === "Nil") { return Data$dMaybe.Nothing; }
+    if (v.tag === "Cons") { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple(v._1, v._2)); }
+    $runtime.fail();
+  }))(dictMonadGen.sized((() => {
+    const $1 = dictMonadRec.tailRecM(v => {
+      if (v._2 <= 0) { return $0.pure(Control$dMonad$dRec$dClass.$Step("Done", v._1)); }
+      const $1 = v._1;
+      const $2 = v._2;
+      return Bind1.bind(gen)(x => $0.pure(Control$dMonad$dRec$dClass.$Step("Loop", Data$dTuple.$Tuple($LL("Cons", x, $1), $2 - 1 | 0))));
+    });
+    const $2 = Data$dTuple.Tuple(Nil);
+    return x => $1($2(x));
+  })()));
+};
+const semigroupFreqSemigroup = {
+  append: v => v1 => pos => {
+    const v2 = v(pos);
+    if (v2._1.tag === "Just") { return v1(v2._1._1); }
+    return v2;
+  }
+};
+const fromIndex = dictFoldable1 => {
+  const foldMap1 = dictFoldable1.foldMap1(Data$dSemigroup$dLast.semigroupLast);
+  return i => xs => {
+    const go = go$a0$copy => go$a1$copy => {
+      let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+      while (go$c) {
+        const v = go$a0, v1 = go$a1;
+        if (v1.tag === "Cons") {
+          if (v1._2.tag === "Nil") {
+            go$c = false;
+            go$r = v1._1;
+            continue;
+          }
+          if (v <= 0) {
+            go$c = false;
+            go$r = v1._1;
+            continue;
+          }
+          go$a0 = v - 1 | 0;
+          go$a1 = v1._2;
+          continue;
+        }
+        if (v1.tag === "Nil") {
+          go$c = false;
+          go$r = foldMap1(Data$dSemigroup$dLast.Last)(xs);
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go(i)(dictFoldable1.Foldable0().foldr(Cons)(Nil)(xs));
+  };
+};
+const oneOf = dictMonadGen => dictFoldable1 => {
+  const length = dictFoldable1.Foldable0().foldl(c => v => 1 + c | 0)(0);
+  const fromIndex1 = fromIndex(dictFoldable1);
+  return xs => dictMonadGen.Monad0().Bind1().bind(dictMonadGen.chooseInt(0)(length(xs) - 1 | 0))(n => fromIndex1(n)(xs));
+};
+const freqSemigroup = v => {
+  const $0 = v._1;
+  const $1 = v._2;
+  return pos => {
+    if (pos >= $0) { return Data$dTuple.$Tuple(Data$dMaybe.$Maybe("Just", pos - $0), $1); }
+    return Data$dTuple.$Tuple(Data$dMaybe.Nothing, $1);
+  };
+};
+const frequency = dictMonadGen => dictFoldable1 => {
+  const foldMap = dictFoldable1.Foldable0().foldMap(monoidAdditive);
+  const foldMap1 = dictFoldable1.foldMap1(semigroupFreqSemigroup);
+  return xs => dictMonadGen.Monad0().Bind1().bind(dictMonadGen.chooseFloat(0.0)(foldMap(Data$dTuple.fst)(xs)))((() => {
+    const $0 = foldMap1(freqSemigroup)(xs);
+    return x => $0(x)._2;
+  })());
+};
+const filtered = dictMonadRec => dictMonadGen => {
+  const $0 = dictMonadGen.Monad0().Bind1().Apply0().Functor0();
+  return gen => dictMonadRec.tailRecM(v => $0.map(a => {
+    if (a.tag === "Nothing") { return Control$dMonad$dRec$dClass.$Step("Loop", undefined); }
+    if (a.tag === "Just") { return Control$dMonad$dRec$dClass.$Step("Done", a._1); }
+    $runtime.fail();
+  })(gen))();
+};
+const suchThat = dictMonadRec => dictMonadGen => {
+  const $0 = dictMonadGen.Monad0().Bind1().Apply0().Functor0();
+  const $1 = dictMonadGen.Monad0().Bind1().Apply0().Functor0();
+  return gen => pred => {
+    const $2 = $1.map(a => {
+      if (pred(a)) { return Data$dMaybe.$Maybe("Just", a); }
+      return Data$dMaybe.Nothing;
+    })(gen);
+    return dictMonadRec.tailRecM(v => $0.map(a => {
+      if (a.tag === "Nothing") { return Control$dMonad$dRec$dClass.$Step("Loop", undefined); }
+      if (a.tag === "Just") { return Control$dMonad$dRec$dClass.$Step("Done", a._1); }
+      $runtime.fail();
+    })($2))();
+  };
+};
+const elements = dictMonadGen => {
+  const Monad0 = dictMonadGen.Monad0();
+  return dictFoldable1 => {
+    const length = dictFoldable1.Foldable0().foldl(c => v => 1 + c | 0)(0);
+    const fromIndex1 = fromIndex(dictFoldable1);
+    return xs => Monad0.Bind1().bind(dictMonadGen.chooseInt(0)(length(xs) - 1 | 0))(n => Monad0.Applicative0().pure(fromIndex1(n)(xs)));
+  };
+};
+const choose = dictMonadGen => {
+  const chooseBool = dictMonadGen.chooseBool;
+  return genA => genB => dictMonadGen.Monad0().Bind1().bind(chooseBool)(v => {
+    if (v) { return genA; }
+    return genB;
+  });
+};
+export {$LL, Cons, Nil, choose, elements, filtered, freqSemigroup, frequency, fromIndex, monoidAdditive, oneOf, semigroupFreqSemigroup, suchThat, unfoldable};

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

@@ -0,0 +1,6 @@
+const sized = dict => dict.sized;
+const resize = dict => dict.resize;
+const chooseInt = dict => dict.chooseInt;
+const chooseFloat = dict => dict.chooseFloat;
+const chooseBool = dict => dict.chooseBool;
+export {chooseBool, chooseFloat, chooseInt, resize, sized};

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

@@ -0,0 +1,44 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dGen from "../Control.Monad.Gen/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 Data$dNonEmpty from "../Data.NonEmpty/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const max = x => y => {
+  const v = Data$dOrd.ordInt.compare(x)(y);
+  if (v === "LT") { return y; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return x; }
+  $runtime.fail();
+};
+const genTuple = dictApply => a => b => dictApply.apply(dictApply.Functor0().map(Data$dTuple.Tuple)(a))(b);
+const genNonEmpty = dictMonadRec => dictMonadGen => {
+  const Apply0 = dictMonadGen.Monad0().Bind1().Apply0();
+  const unfoldable1 = Control$dMonad$dGen.unfoldable(dictMonadRec)(dictMonadGen);
+  return dictUnfoldable => {
+    const unfoldable2 = unfoldable1(dictUnfoldable);
+    return gen => Apply0.apply(Apply0.Functor0().map(Data$dNonEmpty.NonEmpty)(gen))(dictMonadGen.resize(x => max(0)(x - 1 | 0))(unfoldable2(gen)));
+  };
+};
+const genMaybe$p = dictMonadGen => {
+  const Monad0 = dictMonadGen.Monad0();
+  const Bind1 = Monad0.Bind1();
+  return bias => gen => Bind1.bind(dictMonadGen.chooseFloat(0.0)(1.0))(n => {
+    if (n < bias) { return Bind1.Apply0().Functor0().map(Data$dMaybe.Just)(gen); }
+    return Monad0.Applicative0().pure(Data$dMaybe.Nothing);
+  });
+};
+const genMaybe = dictMonadGen => genMaybe$p(dictMonadGen)(0.75);
+const genIdentity = dictFunctor => dictFunctor.map(Data$dIdentity.Identity);
+const genEither$p = dictMonadGen => {
+  const Bind1 = dictMonadGen.Monad0().Bind1();
+  const $0 = Bind1.Apply0().Functor0();
+  return bias => genA => genB => Bind1.bind(dictMonadGen.chooseFloat(0.0)(1.0))(n => {
+    if (n < bias) { return $0.map(Data$dEither.Left)(genA); }
+    return $0.map(Data$dEither.Right)(genB);
+  });
+};
+const genEither = dictMonadGen => genEither$p(dictMonadGen)(0.5);
+export {genEither, genEither$p, genIdentity, genMaybe, genMaybe$p, genNonEmpty, genTuple, max};

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

@@ -0,0 +1,88 @@
+const IdentityT = x => x;
+const traversableIdentityT = dictTraversable => dictTraversable;
+const runIdentityT = v => v;
+const plusIdentityT = dictPlus => dictPlus;
+const newtypeIdentityT = {Coercible0: () => {}};
+const monadWriterIdentityT = dictMonadWriter => dictMonadWriter;
+const monadTransIdentityT = {lift: dictMonad => IdentityT};
+const monadThrowIdentityT = dictMonadThrow => dictMonadThrow;
+const monadTellIdentityT = dictMonadTell => dictMonadTell;
+const monadStateIdentityT = dictMonadState => dictMonadState;
+const monadRecIdentityT = dictMonadRec => dictMonadRec;
+const monadReaderIdentityT = dictMonadReader => dictMonadReader;
+const monadPlusIdentityT = dictMonadPlus => dictMonadPlus;
+const monadIdentityT = dictMonad => dictMonad;
+const monadErrorIdentityT = dictMonadError => dictMonadError;
+const monadEffectIdentityT = dictMonadEffect => dictMonadEffect;
+const monadContIdentityT = dictMonadCont => dictMonadCont;
+const monadAskIdentityT = dictMonadAsk => dictMonadAsk;
+const mapIdentityT = f => v => f(v);
+const functorIdentityT = dictFunctor => dictFunctor;
+const foldableIdentityT = dictFoldable => dictFoldable;
+const eqIdentityT = dictEq1 => dictEq => {
+  const eq11 = dictEq1.eq1(dictEq);
+  return {eq: x => y => eq11(x)(y)};
+};
+const ordIdentityT = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  return dictOrd => {
+    const compare11 = dictOrd1.compare1(dictOrd);
+    const eq11 = $0.eq1(dictOrd.Eq0());
+    const eqIdentityT2 = {eq: x => y => eq11(x)(y)};
+    return {compare: x => y => compare11(x)(y), Eq0: () => eqIdentityT2};
+  };
+};
+const eq1IdentityT = dictEq1 => ({eq1: dictEq => dictEq1.eq1(dictEq)});
+const ord1IdentityT = dictOrd1 => {
+  const $0 = dictOrd1.Eq10();
+  const $1 = dictOrd1.Eq10();
+  const eq1IdentityT1 = {eq1: dictEq => $1.eq1(dictEq)};
+  return {
+    compare1: dictOrd => {
+      const compare11 = dictOrd1.compare1(dictOrd);
+      const eq11 = $0.eq1(dictOrd.Eq0());
+      return (() => {
+        const eqIdentityT2 = {eq: x => y => eq11(x)(y)};
+        return {compare: x => y => compare11(x)(y), Eq0: () => eqIdentityT2};
+      })().compare;
+    },
+    Eq10: () => eq1IdentityT1
+  };
+};
+const bindIdentityT = dictBind => dictBind;
+const applyIdentityT = dictApply => dictApply;
+const applicativeIdentityT = dictApplicative => dictApplicative;
+const alternativeIdentityT = dictAlternative => dictAlternative;
+const altIdentityT = dictAlt => dictAlt;
+export {
+  IdentityT,
+  altIdentityT,
+  alternativeIdentityT,
+  applicativeIdentityT,
+  applyIdentityT,
+  bindIdentityT,
+  eq1IdentityT,
+  eqIdentityT,
+  foldableIdentityT,
+  functorIdentityT,
+  mapIdentityT,
+  monadAskIdentityT,
+  monadContIdentityT,
+  monadEffectIdentityT,
+  monadErrorIdentityT,
+  monadIdentityT,
+  monadPlusIdentityT,
+  monadReaderIdentityT,
+  monadRecIdentityT,
+  monadStateIdentityT,
+  monadTellIdentityT,
+  monadThrowIdentityT,
+  monadTransIdentityT,
+  monadWriterIdentityT,
+  newtypeIdentityT,
+  ord1IdentityT,
+  ordIdentityT,
+  plusIdentityT,
+  runIdentityT,
+  traversableIdentityT
+};