@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Data.Eq/index.js

@@ -0,0 +1,33 @@
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {eqArrayImpl, eqBooleanImpl, eqCharImpl, eqIntImpl, eqNumberImpl, eqStringImpl} from "./foreign.js";
+const eqVoid = {eq: v => v1 => true};
+const eqUnit = {eq: v => v1 => true};
+const eqString = {eq: eqStringImpl};
+const eqRowNil = {eqRecord: v => v1 => v2 => true};
+const eqRecord = dict => dict.eqRecord;
+const eqRec = () => dictEqRecord => ({eq: dictEqRecord.eqRecord(Type$dProxy.Proxy)});
+const eqProxy = {eq: v => v1 => true};
+const eqNumber = {eq: eqNumberImpl};
+const eqInt = {eq: eqIntImpl};
+const eqChar = {eq: eqCharImpl};
+const eqBoolean = {eq: eqBooleanImpl};
+const eq1 = dict => dict.eq1;
+const eq = dict => dict.eq;
+const eqArray = dictEq => ({eq: eqArrayImpl(dictEq.eq)});
+const eq1Array = {eq1: dictEq => eqArrayImpl(dictEq.eq)};
+const eqRowCons = dictEqRecord => () => dictIsSymbol => dictEq => (
+  {
+    eqRecord: v => ra => rb => {
+      const $$get = Record$dUnsafe.unsafeGet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy));
+      return dictEq.eq($$get(ra))($$get(rb)) && dictEqRecord.eqRecord(Type$dProxy.Proxy)(ra)(rb);
+    }
+  }
+);
+const notEq = dictEq => x => y => !dictEq.eq(x)(y);
+const notEq1 = dictEq1 => dictEq => {
+  const eq12 = dictEq1.eq1(dictEq);
+  return x => y => !eq12(x)(y);
+};
+export {eq, eq1, eq1Array, eqArray, eqBoolean, eqChar, eqInt, eqNumber, eqProxy, eqRec, eqRecord, eqRowCons, eqRowNil, eqString, eqUnit, eqVoid, notEq, notEq1};
+export * from "./foreign.js";

package/output-es/Data.Eq.Generic/index.js

@@ -0,0 +1,16 @@
+const genericEqNoConstructors = {"genericEq'": v => v1 => true};
+const genericEqNoArguments = {"genericEq'": v => v1 => true};
+const genericEqArgument = dictEq => ({"genericEq'": v => v1 => dictEq.eq(v)(v1)});
+const genericEq$p = dict => dict["genericEq'"];
+const genericEqConstructor = dictGenericEq => ({"genericEq'": v => v1 => dictGenericEq["genericEq'"](v)(v1)});
+const genericEqProduct = dictGenericEq => dictGenericEq1 => ({"genericEq'": v => v1 => dictGenericEq["genericEq'"](v._1)(v1._1) && dictGenericEq1["genericEq'"](v._2)(v1._2)});
+const genericEqSum = dictGenericEq => dictGenericEq1 => (
+  {
+    "genericEq'": v => v1 => {
+      if (v.tag === "Inl") { return v1.tag === "Inl" && dictGenericEq["genericEq'"](v._1)(v1._1); }
+      return v.tag === "Inr" && v1.tag === "Inr" && dictGenericEq1["genericEq'"](v._1)(v1._1);
+    }
+  }
+);
+const genericEq = dictGeneric => dictGenericEq => x => y => dictGenericEq["genericEq'"](dictGeneric.from(x))(dictGeneric.from(y));
+export {genericEq, genericEq$p, genericEqArgument, genericEqConstructor, genericEqNoArguments, genericEqNoConstructors, genericEqProduct, genericEqSum};

package/output-es/Data.Equivalence/index.js

@@ -0,0 +1,8 @@
+const Equivalence = x => x;
+const semigroupEquivalence = {append: v => v1 => a => b => v(a)(b) && v1(a)(b)};
+const newtypeEquivalence = {Coercible0: () => {}};
+const monoidEquivalence = {mempty: v => v1 => true, Semigroup0: () => semigroupEquivalence};
+const defaultEquivalence = dictEq => dictEq.eq;
+const contravariantEquivalence = {cmap: f => v => x => y => v(f(x))(f(y))};
+const comparisonEquivalence = v => a => b => v(a)(b) === "EQ";
+export {Equivalence, comparisonEquivalence, contravariantEquivalence, defaultEquivalence, monoidEquivalence, newtypeEquivalence, semigroupEquivalence};

package/output-es/Data.EuclideanRing/foreign.js

@@ -0,0 +1,26 @@
+export const intDegree = function (x) {
+  return Math.min(Math.abs(x), 2147483647);
+};
+
+// See the Euclidean definition in
+// https://en.m.wikipedia.org/wiki/Modulo_operation.
+export const intDiv = function (x) {
+  return function (y) {
+    if (y === 0) return 0;
+    return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
+  };
+};
+
+export const intMod = function (x) {
+  return function (y) {
+    if (y === 0) return 0;
+    var yy = Math.abs(y);
+    return ((x % yy) + yy) % yy;
+  };
+};
+
+export const numDiv = function (n1) {
+  return function (n2) {
+    return n1 / n2;
+  };
+};

package/output-es/Data.EuclideanRing/index.js

@@ -0,0 +1,25 @@
+import * as Data$dCommutativeRing from "../Data.CommutativeRing/index.js";
+import {intDegree, intDiv, intMod, numDiv} from "./foreign.js";
+const mod = dict => dict.mod;
+const gcd = dictEq => dictEuclideanRing => {
+  const zero = dictEuclideanRing.CommutativeRing0().Ring0().Semiring0().zero;
+  return a => b => {
+    if (dictEq.eq(b)(zero)) { return a; }
+    return gcd(dictEq)(dictEuclideanRing)(b)(dictEuclideanRing.mod(a)(b));
+  };
+};
+const euclideanRingNumber = {degree: v => 1, div: numDiv, mod: v => v1 => 0.0, CommutativeRing0: () => Data$dCommutativeRing.commutativeRingNumber};
+const euclideanRingInt = {degree: intDegree, div: intDiv, mod: intMod, CommutativeRing0: () => Data$dCommutativeRing.commutativeRingInt};
+const div = dict => dict.div;
+const lcm = dictEq => dictEuclideanRing => {
+  const Semiring0 = dictEuclideanRing.CommutativeRing0().Ring0().Semiring0();
+  const zero = Semiring0.zero;
+  const gcd2 = gcd(dictEq)(dictEuclideanRing);
+  return a => b => {
+    if (dictEq.eq(a)(zero) || dictEq.eq(b)(zero)) { return zero; }
+    return dictEuclideanRing.div(Semiring0.mul(a)(b))(gcd2(a)(b));
+  };
+};
+const degree = dict => dict.degree;
+export {degree, div, euclideanRingInt, euclideanRingNumber, gcd, lcm, mod};
+export * from "./foreign.js";

package/output-es/Data.Exists/index.js

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

package/output-es/Data.Field/index.js

@@ -0,0 +1,2 @@
+const field = dictEuclideanRing => dictDivisionRing => ({EuclideanRing0: () => dictEuclideanRing, DivisionRing1: () => dictDivisionRing});
+export {field};

package/output-es/Data.Filterable/index.js

@@ -0,0 +1,317 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dCompactable from "../Data.Compactable/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dList from "../Data.List/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+const toUnfoldable = x => {
+  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 source = go$a0, memo = go$a1;
+      const v = Data$dMap$dInternal.stepUnfoldr(source);
+      if (v.tag === "Nothing") {
+        const go$1 = go$1$a0$copy => go$1$a1$copy => {
+          let go$1$a0 = go$1$a0$copy, go$1$a1 = go$1$a1$copy, go$1$c = true, go$1$r;
+          while (go$1$c) {
+            const b = go$1$a0, v$1 = go$1$a1;
+            if (v$1.tag === "Nil") {
+              go$1$c = false;
+              go$1$r = b;
+              continue;
+            }
+            if (v$1.tag === "Cons") {
+              go$1$a0 = Data$dList$dTypes.$List("Cons", v$1._1, b);
+              go$1$a1 = v$1._2;
+              continue;
+            }
+            $runtime.fail();
+          }
+          return go$1$r;
+        };
+        go$c = false;
+        go$r = go$1(Data$dList$dTypes.Nil)(memo);
+        continue;
+      }
+      if (v.tag === "Just") {
+        go$a0 = v._1._2;
+        go$a1 = Data$dList$dTypes.$List("Cons", v._1._1, memo);
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go(Data$dMap$dInternal.$MapIter("IterNode", x, Data$dMap$dInternal.IterLeaf))(Data$dList$dTypes.Nil);
+};
+const partitionMapDefault = dictFilterable => p => {
+  const $0 = dictFilterable.Functor1().map(p);
+  return x => dictFilterable.Compactable0().separate($0(x));
+};
+const partitionMap = dict => dict.partitionMap;
+const partition = dict => dict.partition;
+const maybeBool = p => x => {
+  if (p(x)) { return Data$dMaybe.$Maybe("Just", x); }
+  return Data$dMaybe.Nothing;
+};
+const filterableList = {
+  partitionMap: p => xs => Data$dList$dTypes.foldableList.foldr(x => v => {
+    const v1 = p(x);
+    if (v1.tag === "Left") { return {left: Data$dList$dTypes.$List("Cons", v1._1, v.left), right: v.right}; }
+    if (v1.tag === "Right") { return {left: v.left, right: Data$dList$dTypes.$List("Cons", v1._1, v.right)}; }
+    $runtime.fail();
+  })({left: Data$dList$dTypes.Nil, right: Data$dList$dTypes.Nil})(xs),
+  partition: p => xs => Data$dList$dTypes.foldableList.foldr(x => v => {
+    if (p(x)) { return {no: v.no, yes: Data$dList$dTypes.$List("Cons", x, v.yes)}; }
+    return {no: Data$dList$dTypes.$List("Cons", x, v.no), yes: v.yes};
+  })({no: Data$dList$dTypes.Nil, yes: Data$dList$dTypes.Nil})(xs),
+  filterMap: p => {
+    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 === "Nil") {
+          const go$1 = go$1$a0$copy => go$1$a1$copy => {
+            let go$1$a0 = go$1$a0$copy, go$1$a1 = go$1$a1$copy, go$1$c = true, go$1$r;
+            while (go$1$c) {
+              const v$1 = go$1$a0, v1$1 = go$1$a1;
+              if (v1$1.tag === "Nil") {
+                go$1$c = false;
+                go$1$r = v$1;
+                continue;
+              }
+              if (v1$1.tag === "Cons") {
+                go$1$a0 = Data$dList$dTypes.$List("Cons", v1$1._1, v$1);
+                go$1$a1 = v1$1._2;
+                continue;
+              }
+              $runtime.fail();
+            }
+            return go$1$r;
+          };
+          go$c = false;
+          go$r = go$1(Data$dList$dTypes.Nil)(v);
+          continue;
+        }
+        if (v1.tag === "Cons") {
+          const v2 = p(v1._1);
+          if (v2.tag === "Nothing") {
+            go$a0 = v;
+            go$a1 = v1._2;
+            continue;
+          }
+          if (v2.tag === "Just") {
+            go$a0 = Data$dList$dTypes.$List("Cons", v2._1, v);
+            go$a1 = v1._2;
+            continue;
+          }
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go(Data$dList$dTypes.Nil);
+  },
+  filter: Data$dList.filter,
+  Compactable0: () => Data$dCompactable.compactableList,
+  Functor1: () => Data$dList$dTypes.functorList
+};
+const filterableArray = {
+  partitionMap: p => Data$dFoldable.foldlArray(acc => x => {
+    const v = p(x);
+    if (v.tag === "Left") { return {left: [...acc.left, v._1], right: acc.right}; }
+    if (v.tag === "Right") { return {right: [...acc.right, v._1], left: acc.left}; }
+    $runtime.fail();
+  })({left: [], right: []}),
+  partition: Data$dArray.partition,
+  filterMap: Data$dArray.mapMaybe,
+  filter: Data$dArray.filter,
+  Compactable0: () => Data$dCompactable.compactableArray,
+  Functor1: () => Data$dFunctor.functorArray
+};
+const filterMapDefault = dictFilterable => p => {
+  const $0 = dictFilterable.Functor1().map(p);
+  return x => dictFilterable.Compactable0().compact($0(x));
+};
+const filterMap = dict => dict.filterMap;
+const partitionDefaultFilterMap = dictFilterable => p => xs => (
+  {
+    yes: dictFilterable.filterMap(x => {
+      if (p(x)) { return Data$dMaybe.$Maybe("Just", x); }
+      return Data$dMaybe.Nothing;
+    })(xs),
+    no: dictFilterable.filterMap(x => {
+      if (!p(x)) { return Data$dMaybe.$Maybe("Just", x); }
+      return Data$dMaybe.Nothing;
+    })(xs)
+  }
+);
+const filterDefaultPartition = dictFilterable => p => xs => dictFilterable.partition(p)(xs).yes;
+const filterDefault = dictFilterable => x => dictFilterable.filterMap(x$1 => {
+  if (x(x$1)) { return Data$dMaybe.$Maybe("Just", x$1); }
+  return Data$dMaybe.Nothing;
+});
+const filter = dict => dict.filter;
+const partitionDefaultFilter = dictFilterable => p => xs => ({yes: dictFilterable.filter(p)(xs), no: dictFilterable.filter(a => !p(a))(xs)});
+const eitherBool = p => x => {
+  if (p(x)) { return Data$dEither.$Either("Right", x); }
+  return Data$dEither.$Either("Left", x);
+};
+const filterDefaultPartitionMap = dictFilterable => p => xs => dictFilterable.partitionMap(x => {
+  if (p(x)) { return Data$dEither.$Either("Right", x); }
+  return Data$dEither.$Either("Left", x);
+})(xs).right;
+const partitionDefault = dictFilterable => p => xs => {
+  const o = dictFilterable.partitionMap(x => {
+    if (p(x)) { return Data$dEither.$Either("Right", x); }
+    return Data$dEither.$Either("Left", x);
+  })(xs);
+  return {no: o.left, yes: o.right};
+};
+const filterableEither = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  const mempty$1 = dictMonoid.mempty;
+  const compactableEither = {
+    compact: v => {
+      if (v.tag === "Left") { return Data$dEither.$Either("Left", v._1); }
+      if (v.tag === "Right") {
+        if (v._1.tag === "Just") { return Data$dEither.$Either("Right", v._1._1); }
+        if (v._1.tag === "Nothing") { return Data$dEither.$Either("Left", mempty$1); }
+      }
+      $runtime.fail();
+    },
+    separate: v => {
+      if (v.tag === "Left") { return {left: Data$dEither.$Either("Left", v._1), right: Data$dEither.$Either("Left", v._1)}; }
+      if (v.tag === "Right") {
+        if (v._1.tag === "Left") { return {left: Data$dEither.$Either("Right", v._1._1), right: Data$dEither.$Either("Left", mempty$1)}; }
+        if (v._1.tag === "Right") { return {left: Data$dEither.$Either("Left", mempty$1), right: Data$dEither.$Either("Right", v._1._1)}; }
+      }
+      $runtime.fail();
+    }
+  };
+  return {
+    partitionMap: v => v1 => {
+      if (v1.tag === "Left") { return {left: Data$dEither.$Either("Left", v1._1), right: Data$dEither.$Either("Left", v1._1)}; }
+      if (v1.tag === "Right") {
+        const v2 = v(v1._1);
+        if (v2.tag === "Left") { return {left: Data$dEither.$Either("Right", v2._1), right: Data$dEither.$Either("Left", mempty)}; }
+        if (v2.tag === "Right") { return {left: Data$dEither.$Either("Left", mempty), right: Data$dEither.$Either("Right", v2._1)}; }
+      }
+      $runtime.fail();
+    },
+    partition: p => {
+      const $0 = filterableEither(dictMonoid);
+      return xs => {
+        const o = $0.partitionMap(x => {
+          if (p(x)) { return Data$dEither.$Either("Right", x); }
+          return Data$dEither.$Either("Left", x);
+        })(xs);
+        return {no: o.left, yes: o.right};
+      };
+    },
+    filterMap: v => v1 => {
+      if (v1.tag === "Left") { return Data$dEither.$Either("Left", v1._1); }
+      if (v1.tag === "Right") {
+        const v2 = v(v1._1);
+        if (v2.tag === "Nothing") { return Data$dEither.$Either("Left", mempty); }
+        if (v2.tag === "Just") { return Data$dEither.$Either("Right", v2._1); }
+      }
+      $runtime.fail();
+    },
+    filter: p => filterableEither(dictMonoid).filterMap(x => {
+      if (p(x)) { return Data$dMaybe.$Maybe("Just", x); }
+      return Data$dMaybe.Nothing;
+    }),
+    Compactable0: () => compactableEither,
+    Functor1: () => Data$dEither.functorEither
+  };
+};
+const filterableMap = dictOrd => {
+  const alter = Data$dMap$dInternal.alter(dictOrd);
+  const compactableMap = Data$dCompactable.compactableMap(dictOrd);
+  return {
+    partitionMap: p => xs => Data$dList$dTypes.foldableList.foldr(v => v1 => {
+      const v2 = p(v._2);
+      if (v2.tag === "Left") { return {left: Data$dMap$dInternal.insert(dictOrd)(v._1)(v2._1)(v1.left), right: v1.right}; }
+      if (v2.tag === "Right") { return {left: v1.left, right: Data$dMap$dInternal.insert(dictOrd)(v._1)(v2._1)(v1.right)}; }
+      $runtime.fail();
+    })({left: Data$dMap$dInternal.Leaf, right: Data$dMap$dInternal.Leaf})(toUnfoldable(xs)),
+    partition: p => {
+      const $0 = filterableMap(dictOrd);
+      return xs => {
+        const o = $0.partitionMap(x => {
+          if (p(x)) { return Data$dEither.$Either("Right", x); }
+          return Data$dEither.$Either("Left", x);
+        })(xs);
+        return {no: o.left, yes: o.right};
+      };
+    },
+    filterMap: p => xs => Data$dList$dTypes.foldableList.foldr(v => m => alter((() => {
+      const $0 = p(v._2);
+      return v$1 => $0;
+    })())(v._1)(m))(Data$dMap$dInternal.Leaf)(toUnfoldable(xs)),
+    filter: p => filterableMap(dictOrd).filterMap(x => {
+      if (p(x)) { return Data$dMaybe.$Maybe("Just", x); }
+      return Data$dMaybe.Nothing;
+    }),
+    Compactable0: () => compactableMap,
+    Functor1: () => Data$dMap$dInternal.functorMap
+  };
+};
+const filterableMaybe = {
+  partitionMap: v => v1 => {
+    if (v1.tag === "Nothing") { return {left: Data$dMaybe.Nothing, right: Data$dMaybe.Nothing}; }
+    if (v1.tag === "Just") {
+      const v2 = v(v1._1);
+      if (v2.tag === "Left") { return {left: Data$dMaybe.$Maybe("Just", v2._1), right: Data$dMaybe.Nothing}; }
+      if (v2.tag === "Right") { return {left: Data$dMaybe.Nothing, right: Data$dMaybe.$Maybe("Just", v2._1)}; }
+    }
+    $runtime.fail();
+  },
+  partition: p => xs => {
+    const o = filterableMaybe.partitionMap(x => {
+      if (p(x)) { return Data$dEither.$Either("Right", x); }
+      return Data$dEither.$Either("Left", x);
+    })(xs);
+    return {no: o.left, yes: o.right};
+  },
+  filterMap: b => a => {
+    if (a.tag === "Just") { return b(a._1); }
+    if (a.tag === "Nothing") { return Data$dMaybe.Nothing; }
+    $runtime.fail();
+  },
+  filter: p => filterableMaybe.filterMap(x => {
+    if (p(x)) { return Data$dMaybe.$Maybe("Just", x); }
+    return Data$dMaybe.Nothing;
+  }),
+  Compactable0: () => Data$dCompactable.compactableMaybe,
+  Functor1: () => Data$dMaybe.functorMaybe
+};
+const cleared = dictFilterable => dictFilterable.filterMap(v => Data$dMaybe.Nothing);
+export {
+  cleared,
+  eitherBool,
+  filter,
+  filterDefault,
+  filterDefaultPartition,
+  filterDefaultPartitionMap,
+  filterMap,
+  filterMapDefault,
+  filterableArray,
+  filterableEither,
+  filterableList,
+  filterableMap,
+  filterableMaybe,
+  maybeBool,
+  partition,
+  partitionDefault,
+  partitionDefaultFilter,
+  partitionDefaultFilterMap,
+  partitionMap,
+  partitionMapDefault,
+  toUnfoldable
+};

package/output-es/Data.Foldable/foreign.js

@@ -0,0 +1,25 @@
+export const foldrArray = function (f) {
+  return function (init) {
+    return function (xs) {
+      var acc = init;
+      var len = xs.length;
+      for (var i = len - 1; i >= 0; i--) {
+        acc = f(xs[i])(acc);
+      }
+      return acc;
+    };
+  };
+};
+
+export const foldlArray = function (f) {
+  return function (init) {
+    return function (xs) {
+      var acc = init;
+      var len = xs.length;
+      for (var i = 0; i < len; i++) {
+        acc = f(acc)(xs[i]);
+      }
+      return acc;
+    };
+  };
+};