@explorable-viz/fluid 0.12.3 → 0.12.4

package/output-es/Util/index.js

@@ -0,0 +1,340 @@
+import * as $runtime from "../runtime.js";
+import * as Control$dApplicative from "../Control.Applicative/index.js";
+import * as Control$dBind from "../Control.Bind/index.js";
+import * as Control$dCategory from "../Control.Category/index.js";
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dArray$dNonEmpty from "../Data.Array.NonEmpty/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dList from "../Data.List/index.js";
+import * as Data$dList$dNonEmpty from "../Data.List.NonEmpty/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";
+import * as Data$dNonEmpty from "../Data.NonEmpty/index.js";
+import * as Data$dProfunctor$dStrong from "../Data.Profunctor.Strong/index.js";
+import * as Data$dSet from "../Data.Set/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Debug from "../Debug/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+const $WithTypeLeft = (_1, _2) => ({tag: "WithTypeLeft", _1, _2});
+const fanout = /* #__PURE__ */ Data$dProfunctor$dStrong.fanout(Control$dCategory.categoryFn)(Data$dProfunctor$dStrong.strongFn);
+const intercalate = sep => 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 b = go$a0, v = go$a1;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = b;
+        continue;
+      }
+      if (v.tag === "Cons") {
+        go$a0 = b.init
+          ? {init: false, acc: v._1}
+          : {init: false, acc: Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(v._1)(sep))(b.acc)};
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go({init: true, acc: Data$dList$dTypes.Nil})(xs).acc;
+};
+const identity = x => x;
+const WithTypeLeft = value0 => value1 => $WithTypeLeft(value0, value1);
+const zipList = {zip: Data$dList.zip, zipWith: Data$dList.zipWith};
+const zipArray = {zip: /* #__PURE__ */ Data$dArray.zipWith(Data$dTuple.Tuple), zipWith: Data$dArray.zipWith};
+const singletonSet = {singleton: Data$dSet.singleton};
+const singletonNonEmptySet = {singleton: Data$dSet.singleton};
+const singletonNonEmptyList = /* #__PURE__ */ (() => ({singleton: Data$dList$dTypes.applicativeNonEmptyList.pure}))();
+const singletonList = /* #__PURE__ */ (() => ({singleton: Data$dList$dTypes.applicativeList.pure}))();
+const singletonArray = /* #__PURE__ */ (() => ({singleton: Control$dApplicative.applicativeArray.pure}))();
+const lengthList = {length: Data$dList.length};
+const lengthArray = {length: Data$dArray.length};
+const isEmptySet = {isEmpty: Data$dMap$dInternal.isEmpty};
+const isEmptyObject = {isEmpty: Foreign$dObject.isEmpty};
+const functor$x60$x215$x124 = dictFunctor => ({map: f => m => $WithTypeLeft(m._1, dictFunctor.map(f)(m._2))});
+const zipWith = dict => dict.zipWith;
+const zip = dict => dict.zip;
+const $$with = x => f => Data$dTuple.$Tuple(x, f(x));
+const whenever = v => {
+  if (!v) { return v$1 => Data$dMaybe.Nothing; }
+  if (v) { return Data$dMaybe.Just; }
+  $runtime.fail();
+};
+const unzip = dictFunctor => fanout(v => dictFunctor.map(Data$dTuple.fst)(v))(v => dictFunctor.map(Data$dTuple.snd)(v));
+const unsafeUpdateAt = dict => dict.unsafeUpdateAt;
+const unsafeIndex = dict => dict.unsafeIndex;
+const unionWithMaybe = dictOrd => {
+  const compare = dictOrd.compare;
+  return f => m => m$p => {
+    const go = v => {
+      if (v.tag === "Leaf") { return Data$dMap$dInternal.Leaf; }
+      if (v.tag === "Node") { return Data$dMap$dInternal.$$$Map("Node", v._1, v._2, v._3, Data$dMaybe.$Maybe("Just", v._4), go(v._5), go(v._6)); }
+      $runtime.fail();
+    };
+    const go$1 = v => {
+      if (v.tag === "Leaf") { return Data$dMap$dInternal.Leaf; }
+      if (v.tag === "Node") { return Data$dMap$dInternal.$$$Map("Node", v._1, v._2, v._3, Data$dMaybe.$Maybe("Just", v._4), go$1(v._5), go$1(v._6)); }
+      $runtime.fail();
+    };
+    return Data$dMap$dInternal.unsafeUnionWith(
+      compare,
+      x => x$1 => {
+        if (x.tag === "Just" && x$1.tag === "Just") { return f(x._1)(x$1._1); }
+        return Data$dMaybe.Nothing;
+      },
+      go(m),
+      go$1(m$p)
+    );
+  };
+};
+const unimplemented = "unimplemented";
+const uncurry3 = f => v => f(v._1)(v._2._1)(v._2._2);
+const tuple3 = a => b => c => Data$dTuple.$Tuple(a, Data$dTuple.$Tuple(b, c));
+const throwLeft = dictMonadError => {
+  const $0 = dictMonadError.MonadThrow0();
+  const $1 = $0.Monad0().Applicative0().pure;
+  return dictShow => x => {
+    if (x.tag === "Left") { return $0.throwError(Effect$dException.error(dictShow.show(x._1))); }
+    if (x.tag === "Right") { return $1(x._1); }
+    $runtime.fail();
+  };
+};
+const $$throw = dictMonadThrow => x => dictMonadThrow.throwError(Effect$dException.error(x));
+const withMsg = dictMonadError => {
+  const throw2 = $$throw(dictMonadError.MonadThrow0());
+  return msg => m => dictMonadError.catchError(m)(e => throw2(Effect$dException.message(e) + (msg === "" ? "" : "\n" + msg)));
+};
+const withMsg1 = /* #__PURE__ */ withMsg(/* #__PURE__ */ Control$dMonad$dExcept$dTrans.monadErrorExceptT(Data$dIdentity.monadIdentity));
+const tail = dict => dict.tail;
+const slipl = f => c => a => b => f(a)(b)(c);
+const singleton = dict => dict.singleton;
+const orElse = dictMonadThrow => v => v1 => {
+  if (v1.tag === "Nothing") { return dictMonadThrow.throwError(Effect$dException.error(v)); }
+  if (v1.tag === "Just") { return dictMonadThrow.Monad0().Applicative0().pure(v1._1); }
+  $runtime.fail();
+};
+const onlyIf = dictBind => dictAlternative => {
+  const empty = dictAlternative.Plus1().empty;
+  return b => a => dictBind.bind(b ? dictAlternative.Applicative0().pure() : empty)(() => dictAlternative.Applicative0().pure(a));
+};
+const om = dictMonad => f => m => x => dictMonad.Bind1().bind(m)(a => f(a)(x));
+const nonEmpty = dict => dict.nonEmpty;
+const mayEq = dictEq => x => x$p => {
+  const $0 = dictEq.eq(x)(x$p);
+  if (!$0) { return Data$dMaybe.Nothing; }
+  if ($0) { return Data$dMaybe.$Maybe("Just", x); }
+  $runtime.fail();
+};
+const mayFailEq = dictMonadThrow => dictShow => dictEq => x => x$p => orElse(dictMonadThrow)(dictShow.show(x) + " ≠ " + dictShow.show(x$p))((() => {
+  const $0 = dictEq.eq(x)(x$p);
+  if (!$0) { return Data$dMaybe.Nothing; }
+  if ($0) { return Data$dMaybe.$Maybe("Just", x); }
+  $runtime.fail();
+})());
+const length = dict => dict.length;
+const isEmpty = dict => dict.isEmpty;
+const intersperse = x => xs => intercalate(Data$dList$dTypes.$List("Cons", x, Data$dList$dTypes.Nil))(Data$dList$dTypes.listMap(Data$dList$dTypes.applicativeList.pure)(xs));
+const init = dict => dict.init;
+const force = v => v();
+const findM = dictAlt => {
+  const alt = dictAlt.alt;
+  return dictMonad => {
+    const $0 = dictMonad.Bind1().Apply0();
+    return dictFoldable => xs => f => base => dictFoldable.foldr(x => acc => $0.apply($0.Functor0().map(alt)(acc))(f(x)))(dictMonad.Applicative0().pure(base))(xs);
+  };
+};
+const error = msg => Effect$dException.throwException(Effect$dException.error(msg))();
+const shapeMismatch = v => Effect$dException.throwException(Effect$dException.error("Shape mismatch"))();
+const dup = x => Data$dTuple.$Tuple(x, x);
+const definitely = v => v1 => {
+  if (v1.tag === "Just") { return v1._1; }
+  if (v1.tag === "Nothing") { return Effect$dException.throwException(Effect$dException.error("definitely " + v))(); }
+  $runtime.fail();
+};
+const withinBounds = /* #__PURE__ */ definitely("index within bounds");
+const unsafeArrayArray = {
+  unsafeIndex: xs => i => definitely("index within bounds")(i >= 0 && i < xs.length ? Data$dMaybe.$Maybe("Just", xs[i]) : Data$dMaybe.Nothing),
+  unsafeUpdateAt: i => x => x$1 => definitely("index within bounds")(Data$dArray._updateAt(Data$dMaybe.Just, Data$dMaybe.Nothing, i, x, x$1))
+};
+const unsafeArrayNonEmptyArray = {
+  unsafeIndex: xs => i => definitely("index within bounds")(i >= 0 && i < xs.length ? Data$dMaybe.$Maybe("Just", xs[i]) : Data$dMaybe.Nothing),
+  unsafeUpdateAt: i => x => x$1 => definitely("index within bounds")(Data$dArray._updateAt(Data$dMaybe.Just, Data$dMaybe.Nothing, i, x, x$1))
+};
+const nonEmptyArrayNonEmptyArra = {
+  nonEmpty: x => definitely("non-empty")(x.length > 0 ? Data$dMaybe.$Maybe("Just", x) : Data$dMaybe.Nothing),
+  init: Data$dArray$dNonEmpty.init,
+  tail: Data$dArray$dNonEmpty.tail
+};
+const nonEmptyListNonEmptyList = {
+  nonEmpty: x => definitely("non-empty")((() => {
+    if (x.tag === "Nil") { return Data$dMaybe.Nothing; }
+    if (x.tag === "Cons") { return Data$dMaybe.$Maybe("Just", Data$dNonEmpty.$NonEmpty(x._1, x._2)); }
+    $runtime.fail();
+  })()),
+  init: Data$dList$dNonEmpty.init,
+  tail: Data$dList$dNonEmpty.tail
+};
+const defined = x => {
+  if (x.tag === "Right") { return x._1; }
+  if (x.tag === "Left") { return Effect$dException.throwException(Effect$dException.error(Effect$dException.showErrorImpl(x._1)))(); }
+  $runtime.fail();
+};
+const definedWith = msg => {
+  const $0 = withMsg1(msg);
+  return x => defined($0(x));
+};
+const debug = {logging: false, tracing: true};
+const log$p = dictMonadEffect => {
+  const $0 = dictMonadEffect.Monad0().Applicative0();
+  return msg => $0.pure();
+};
+const spyWhen = v => v1 => v2 => v3 => {
+  if (v) { return Debug._trace(v1 + ":", v4 => Debug._trace(v2(v3), v$1 => v3)); }
+  return v3;
+};
+const spy = /* #__PURE__ */ spyWhen(true);
+const spyFunWhenM = dictFunctor => b => s => showIn => showOut => f => x => dictFunctor.map(spyWhen(b)(s + " output")(showOut))(f(spyWhen(b)(s + " input")(showIn)(x)));
+const spyFunWhen = b => s => showIn => showOut => f => spyFunWhenM(Data$dIdentity.functorIdentity)(b)(s)(showIn)(showOut)(x => f(x));
+const traceWhen = dictApplicative => v => v1 => {
+  if (v) { return Debug._trace(v1, v2 => dictApplicative.pure()); }
+  return dictApplicative.pure();
+};
+const trace = dictApplicative => traceWhen(dictApplicative)(true);
+const concatM = dictFoldable => dictMonad => dictFoldable.foldr((() => {
+  const $0 = dictMonad.Bind1();
+  return f => g => a => $0.bind(f(a))(g);
+})())(dictMonad.Applicative0().pure);
+const checkSatisfies = dictMonadThrow => {
+  const $0 = dictMonadThrow.Monad0().Applicative0();
+  return dictShow => msg => x => pred => {
+    const $1 = pred(x);
+    const $2 = dictMonadThrow.throwError(Effect$dException.error(dictShow.show(x) + " doesn't satisfy " + msg));
+    if (!$1) { return $2; }
+    if ($1) { return $0.pure(); }
+    $runtime.fail();
+  };
+};
+const check = dictMonadThrow => v => {
+  if (!v) { return $$throw(dictMonadThrow); }
+  if (v) {
+    const $0 = dictMonadThrow.Monad0().Applicative0().pure();
+    return v$1 => $0;
+  }
+  $runtime.fail();
+};
+const both = dictCategory => {
+  const $0 = dictCategory.Semigroupoid0();
+  return dictStrong => f => $0.compose(dictStrong.second(f))(dictStrong.first(f));
+};
+const bind2Flipped = dictMonad => {
+  const Bind1 = dictMonad.Bind1();
+  const $0 = Bind1.Apply0();
+  return f => x => y => Bind1.bind($0.apply($0.Functor0().map(f)(x))(y))(Control$dBind.identity);
+};
+const assoc2 = v => Data$dTuple.$Tuple(Data$dTuple.$Tuple(v._1, v._2._1), v._2._2);
+const assoc1 = v => Data$dTuple.$Tuple(v._1._1, Data$dTuple.$Tuple(v._1._2, v._2));
+const assertWith = v => v1 => {
+  if (v1) { return identity; }
+  return v2 => Effect$dException.throwException(Effect$dException.error("Assertion failure: " + v))();
+};
+const assertWhen = v => v1 => {
+  if (!v) { return v$1 => identity; }
+  if (v) { return x => assertWith(v1)(x()); }
+  $runtime.fail();
+};
+const mustEq = dictEq => dictShow => x => x$p => assertWhen(false)("mustEq")(v => dictEq.eq(x)(x$p))(x);
+const validateWhen = b => msg => p => a => assertWhen(b)(msg)(v => p(a))(a);
+const validate = /* #__PURE__ */ validateWhen(true);
+const assert = /* #__PURE__ */ assertWith("");
+const appendList = v => ys => Data$dNonEmpty.$NonEmpty(v._1, Data$dList$dTypes.foldableList.foldr(Data$dList$dTypes.Cons)(ys)(v._2));
+const absurd = "absurd";
+const definitely$p = /* #__PURE__ */ definitely("absurd");
+export {
+  $WithTypeLeft,
+  WithTypeLeft,
+  absurd,
+  appendList,
+  assert,
+  assertWhen,
+  assertWith,
+  assoc1,
+  assoc2,
+  bind2Flipped,
+  both,
+  check,
+  checkSatisfies,
+  concatM,
+  debug,
+  defined,
+  definedWith,
+  definitely,
+  definitely$p,
+  dup,
+  error,
+  fanout,
+  findM,
+  force,
+  functor$x60$x215$x124,
+  identity,
+  init,
+  intercalate,
+  intersperse,
+  isEmpty,
+  isEmptyObject,
+  isEmptySet,
+  length,
+  lengthArray,
+  lengthList,
+  log$p,
+  mayEq,
+  mayFailEq,
+  mustEq,
+  nonEmpty,
+  nonEmptyArrayNonEmptyArra,
+  nonEmptyListNonEmptyList,
+  om,
+  onlyIf,
+  orElse,
+  shapeMismatch,
+  singleton,
+  singletonArray,
+  singletonList,
+  singletonNonEmptyList,
+  singletonNonEmptySet,
+  singletonSet,
+  slipl,
+  spy,
+  spyFunWhen,
+  spyFunWhenM,
+  spyWhen,
+  tail,
+  $$throw as throw,
+  throwLeft,
+  trace,
+  traceWhen,
+  tuple3,
+  uncurry3,
+  unimplemented,
+  unionWithMaybe,
+  unsafeArrayArray,
+  unsafeArrayNonEmptyArray,
+  unsafeIndex,
+  unsafeUpdateAt,
+  unzip,
+  validate,
+  validateWhen,
+  whenever,
+  $$with as with,
+  withMsg,
+  withMsg1,
+  withinBounds,
+  zip,
+  zipArray,
+  zipList,
+  zipWith
+};

package/output-es/Util.Map/foreign.js

@@ -0,0 +1,13 @@
+export function intersectionWith_Object (f) {
+   return function (m1) {
+      return function (m2) {
+         var m = {}
+         for (var k in m1) {
+            if (hasOwnProperty.call(m1, k) && hasOwnProperty.call(m2, k)) {
+               m[k] = f(m1[k])(m2[k])
+            }
+         }
+         return m
+      }
+   }
+}

package/output-es/Util.Map/index.js

@@ -0,0 +1,129 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunction from "../Data.Function/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";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+import * as Util from "../Util/index.js";
+import * as Util$dSet from "../Util.Set/index.js";
+import {intersectionWith_Object} from "./foreign.js";
+const identity = x => x;
+const mapObjectString = {
+  maplet: Foreign$dObject.singleton,
+  keys: /* #__PURE__ */ (() => {
+    const $0 = Data$dFoldable.foldlArray(m => a => Data$dMap$dInternal.insert(Data$dOrd.ordString)(a)()(m))(Data$dMap$dInternal.Leaf);
+    return x => $0(Object.keys(x));
+  })(),
+  values: /* #__PURE__ */ (() => {
+    const $0 = Data$dFoldable.foldrArray(Data$dList$dTypes.Cons)(Data$dList$dTypes.Nil);
+    return x => $0(Foreign$dObject.values(x));
+  })(),
+  filterKeys: Foreign$dObject.filterKeys,
+  unionWith: Foreign$dObject.unionWith,
+  lookup: Foreign$dObject.lookup,
+  delete: Foreign$dObject.delete,
+  insert: Foreign$dObject.insert,
+  toUnfoldable: dictUnfoldable => Foreign$dObject.toAscUnfoldable(dictUnfoldable),
+  Set0: () => Util$dSet.setObjectString
+};
+const values = dict => dict.values;
+const unionWith = dict => dict.unionWith;
+const toUnfoldable = dict => dict.toUnfoldable;
+const maplet = dict => dict.maplet;
+const mapWithKey = dict => dict.mapWithKey;
+const lookup = dict => dict.lookup;
+const keys = dict => dict.keys;
+const keyExists = dictShow => k => "Key " + dictShow.show(k) + " exists in map";
+const lookup$p = dictMonadThrow => dictShow => dictMap => k => γ => Util.orElse(dictMonadThrow)("Key " + dictShow.show(k) + " exists in map")(dictMap.lookup(k)(γ));
+const intersectionWith = dict => dict.intersectionWith;
+const intersection = dictMapF => dictMapF.intersectionWith(Data$dFunction.const);
+const insert = dict => dict.insert;
+const $$get = dictShow => dictMap => k => {
+  const $0 = dictMap.lookup(k);
+  const $1 = Util.definitely("Key " + dictShow.show(k) + " exists in map");
+  return x => $1($0(x));
+};
+const filterKeys = dict => dict.filterKeys;
+const restrict = dictOrd => dictMap => xs => dictMap.filterKeys(v => Util$dSet.setSet(dictOrd).member(v)(xs));
+const disjointUnion_inv = dictOrd => {
+  const $0 = Util$dSet.setSet(dictOrd);
+  return dictMap => ks => m => Data$dTuple.$Tuple(dictMap.filterKeys(v => $0.member(v)(ks))(m), dictMap.filterKeys(v => !$0.member(v)(ks))(m));
+};
+const disjointUnion = dictMap => dictMap.unionWith(v => v1 => Effect$dException.throwException(Effect$dException.error("not disjoint"))());
+const difference = dict => dict.difference;
+const $$delete = dict => dict.delete;
+const mapFObjectString = {
+  intersectionWith: intersectionWith_Object,
+  difference: m1 => m2 => Data$dFoldable.foldlArray(b => a => Foreign$dObject.mutate($0 => () => {
+    delete $0[a];
+    return $0;
+  })(b))(m1)(Object.keys(m2)),
+  mapWithKey: Foreign$dObject.mapWithKey
+};
+const asMaplet = dictMap => {
+  const toUnfoldable1 = dictMap.toUnfoldable(Data$dList$dTypes.unfoldableList);
+  return m => Util.assertWith("")(dictMap.Set0().size(m) === 1)(Util.definitely("singleton map")((() => {
+    const $0 = toUnfoldable1(m);
+    if ($0.tag === "Nil") { return Data$dMaybe.Nothing; }
+    if ($0.tag === "Cons") { return Data$dMaybe.$Maybe("Just", $0._1); }
+    $runtime.fail();
+  })()));
+};
+const append_inv = dictOrd => dictMap => xs => γ => Data$dTuple.$Tuple(
+  dictMap.filterKeys(v => !Util$dSet.setSet(dictOrd).member(v)(xs))(γ),
+  dictMap.filterKeys(v => Util$dSet.setSet(dictOrd).member(v)(xs))(γ)
+);
+const append = dictMap => dictMap.unionWith(v => identity);
+const alter = dictMap => f => k => m => {
+  const v = f(dictMap.lookup(k)(m));
+  if (v.tag === "Nothing") { return dictMap.delete(k)(m); }
+  if (v.tag === "Just") { return dictMap.insert(k)(v._1)(m); }
+  $runtime.fail();
+};
+const insertWith = dictMap => f => k => v => m => {
+  const $0 = dictMap.lookup(k)(m);
+  return dictMap.insert(k)((() => {
+    if ($0.tag === "Nothing") { return v; }
+    if ($0.tag === "Just") { return f($0._1)(v); }
+    $runtime.fail();
+  })())(m);
+};
+const update = dictShow => dictMap => f => k => {
+  const $0 = Util.definitely("Key " + dictShow.show(k) + " exists in map");
+  return m => dictMap.insert(k)(f($0(dictMap.lookup(k)(m))))(m);
+};
+export {
+  alter,
+  append,
+  append_inv,
+  asMaplet,
+  $$delete as delete,
+  difference,
+  disjointUnion,
+  disjointUnion_inv,
+  filterKeys,
+  $$get as get,
+  identity,
+  insert,
+  insertWith,
+  intersection,
+  intersectionWith,
+  keyExists,
+  keys,
+  lookup,
+  lookup$p,
+  mapFObjectString,
+  mapObjectString,
+  mapWithKey,
+  maplet,
+  restrict,
+  toUnfoldable,
+  unionWith,
+  update,
+  values
+};
+export * from "./foreign.js";

package/output-es/Util.Pair/index.js

@@ -0,0 +1,90 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dFoldable from "../Data.Foldable/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$dOrdering from "../Data.Ordering/index.js";
+import * as Data$dTraversable from "../Data.Traversable/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const $Pair = (_1, _2) => ({tag: "Pair", _1, _2});
+const Pair = value0 => value1 => $Pair(value0, value1);
+const showPair = dictShow => ({show: v => "(Pair " + dictShow.show(v._1) + " " + dictShow.show(v._2) + ")"});
+const functorPair = {map: f => v => $Pair(f(v._1), f(v._2))};
+const foldablePair = {
+  foldl: f => z => v => f(f(z)(v._1))(v._2),
+  foldr: f => Data$dFoldable.foldrDefault(foldablePair)(f),
+  foldMap: dictMonoid => f => foldablePair.foldl(acc => x => dictMonoid.Semigroup0().append(acc)(f(x)))(dictMonoid.mempty)
+};
+const traversablePair = {
+  traverse: dictApplicative => {
+    const Apply0 = dictApplicative.Apply0();
+    return f => v => Apply0.apply(Apply0.Functor0().map(Pair)(f(v._1)))(f(v._2));
+  },
+  sequence: dictApplicative => traversablePair.traverse(dictApplicative)(Data$dTraversable.identity),
+  Functor0: () => functorPair,
+  Foldable1: () => foldablePair
+};
+const eqPair = dictEq => ({eq: x => y => dictEq.eq(x._1)(y._1) && dictEq.eq(x._2)(y._2)});
+const ordPair = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  const eqPair1 = {eq: x => y => $0.eq(x._1)(y._1) && $0.eq(x._2)(y._2)};
+  return {
+    compare: x => y => {
+      const v = dictOrd.compare(x._1)(y._1);
+      if (v === "LT") { return Data$dOrdering.LT; }
+      if (v === "GT") { return Data$dOrdering.GT; }
+      return dictOrd.compare(x._2)(y._2);
+    },
+    Eq0: () => eqPair1
+  };
+};
+const applyPair = {apply: v => v1 => $Pair(v._1(v1._1), v._2(v1._2)), Functor0: () => functorPair};
+const applicativePair = {pure: x => $Pair(x, x), Apply0: () => applyPair};
+const toTuple = v => Data$dTuple.$Tuple(v._1, v._2);
+const unzip = xys => Data$dList.unzip(Data$dList$dTypes.listMap(toTuple)(xys));
+const fromTuple = v => $Pair(v._1, v._2);
+const zip = xs => ys => {
+  const go = go$a0$copy => go$a1$copy => go$a2$copy => {
+    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$a2 = go$a2$copy, go$c = true, go$r;
+    while (go$c) {
+      const v = go$a0, v1 = go$a1, v2 = go$a2;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = v2;
+        continue;
+      }
+      if (v1.tag === "Nil") {
+        go$c = false;
+        go$r = v2;
+        continue;
+      }
+      if (v.tag === "Cons" && v1.tag === "Cons") {
+        go$a0 = v._2;
+        go$a1 = v1._2;
+        go$a2 = Data$dList$dTypes.$List("Cons", Data$dTuple.$Tuple(v._1, v1._1), v2);
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  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 = go$1$a0, v1 = go$1$a1;
+      if (v1.tag === "Nil") {
+        go$1$c = false;
+        go$1$r = v;
+        continue;
+      }
+      if (v1.tag === "Cons") {
+        go$1$a0 = Data$dList$dTypes.$List("Cons", v1._1, v);
+        go$1$a1 = v1._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$1$r;
+  };
+  return Data$dList$dTypes.listMap(fromTuple)(go$1(Data$dList$dTypes.Nil)(go(xs)(ys)(Data$dList$dTypes.Nil)));
+};
+export {$Pair, Pair, applicativePair, applyPair, eqPair, foldablePair, fromTuple, functorPair, ordPair, showPair, toTuple, traversablePair, unzip, zip};

package/output-es/Util.Set/index.js

@@ -0,0 +1,75 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunction from "../Data.Function/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dSet from "../Data.Set/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+import * as Util from "../Util/index.js";
+const setSet = dictOrd => (
+  {
+    empty: Data$dMap$dInternal.Leaf,
+    filter: Data$dSet.filter(dictOrd),
+    size: Data$dMap$dInternal.size,
+    difference: (() => {
+      const compare = dictOrd.compare;
+      return m1 => m2 => Data$dMap$dInternal.unsafeDifference(compare, m1, m2);
+    })(),
+    member: k => {
+      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 === "Leaf") {
+            go$c = false;
+            go$r = false;
+            continue;
+          }
+          if (v.tag === "Node") {
+            const v1 = dictOrd.compare(k)(v._3);
+            if (v1 === "LT") {
+              go$a0 = v._5;
+              continue;
+            }
+            if (v1 === "GT") {
+              go$a0 = v._6;
+              continue;
+            }
+            if (v1 === "EQ") {
+              go$c = false;
+              go$r = true;
+              continue;
+            }
+          }
+          $runtime.fail();
+        }
+        return go$r;
+      };
+      return go;
+    },
+    union: (() => {
+      const compare = dictOrd.compare;
+      return m1 => m2 => Data$dMap$dInternal.unsafeUnionWith(compare, Data$dFunction.const, m1, m2);
+    })(),
+    IsEmpty0: () => Util.isEmptySet
+  }
+);
+const setObjectString = {
+  empty: Foreign$dObject.empty,
+  filter: Foreign$dObject.filterKeys,
+  size: Foreign$dObject.size,
+  difference: x => y => Data$dFoldable.foldlArray(b => a => Foreign$dObject.mutate($0 => () => {
+    delete $0[a];
+    return $0;
+  })(b))(x)(Object.keys(y)),
+  member: Foreign$dObject.member,
+  union: Foreign$dObject.union,
+  IsEmpty0: () => Util.isEmptyObject
+};
+const union = dict => dict.union;
+const size = dict => dict.size;
+const member = dict => dict.member;
+const filter = dict => dict.filter;
+const empty = dict => dict.empty;
+const unions = dictFoldable => dictSet => dictFoldable.foldl(dictSet.union)(dictSet.empty);
+const difference = dict => dict.difference;
+export {difference, empty, filter, member, setObjectString, setSet, size, union, unions};