@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Foreign.Keys/index.js

@@ -0,0 +1,28 @@
+// | This module provides functions for working with object properties
+// | of Javascript objects.
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dNonEmpty from "../Data.NonEmpty/index.js";
+import * as Foreign from "../Foreign/index.js";
+import {unsafeKeys} from "./foreign.js";
+const keys = dictMonad => value => {
+  if (Foreign.isNull(value)) {
+    return Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty(
+      Foreign.$ForeignError("TypeMismatch", "object", "null"),
+      Data$dList$dTypes.Nil
+    ));
+  }
+  if (Foreign.isUndefined(value)) {
+    return Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty(
+      Foreign.$ForeignError("TypeMismatch", "object", "undefined"),
+      Data$dList$dTypes.Nil
+    ));
+  }
+  if (Foreign.typeOf(value) === "object") { return Control$dMonad$dExcept$dTrans.applicativeExceptT(dictMonad).pure(unsafeKeys(value)); }
+  return Control$dMonad$dExcept$dTrans.monadThrowExceptT(dictMonad).throwError(Data$dNonEmpty.$NonEmpty(
+    Foreign.$ForeignError("TypeMismatch", "object", Foreign.typeOf(value)),
+    Data$dList$dTypes.Nil
+  ));
+};
+export {keys};
+export * from "./foreign.js";

package/output-es/Foreign.Object/foreign.js

@@ -0,0 +1,116 @@
+export function _copyST(m) {
+  return function () {
+    var r = {};
+    for (var k in m) {
+      if (hasOwnProperty.call(m, k)) {
+        r[k] = m[k];
+      }
+    }
+    return r;
+  };
+}
+
+export const empty = {};
+
+export function runST(f) {
+  return f();
+}
+
+export function _fmapObject(m0, f) {
+  var m = {};
+  for (var k in m0) {
+    if (hasOwnProperty.call(m0, k)) {
+      m[k] = f(m0[k]);
+    }
+  }
+  return m;
+}
+
+export function _mapWithKey(m0, f) {
+  var m = {};
+  for (var k in m0) {
+    if (hasOwnProperty.call(m0, k)) {
+      m[k] = f(k)(m0[k]);
+    }
+  }
+  return m;
+}
+
+export function _foldM(bind) {
+  return function (f) {
+    return function (mz) {
+      return function (m) {
+        var acc = mz;
+        function g(k) {
+          return function (z) {
+            return f(z)(k)(m[k]);
+          };
+        }
+        for (var k in m) {
+          if (hasOwnProperty.call(m, k)) {
+            acc = bind(acc)(g(k));
+          }
+        }
+        return acc;
+      };
+    };
+  };
+}
+
+export function _foldSCObject(m, z, f, fromMaybe) {
+  var acc = z;
+  for (var k in m) {
+    if (hasOwnProperty.call(m, k)) {
+      var maybeR = f(acc)(k)(m[k]);
+      var r = fromMaybe(null)(maybeR);
+      if (r === null) return acc;
+      else acc = r;
+    }
+  }
+  return acc;
+}
+
+export function all(f) {
+  return function (m) {
+    for (var k in m) {
+      if (hasOwnProperty.call(m, k) && !f(k)(m[k])) return false;
+    }
+    return true;
+  };
+}
+
+export function size(m) {
+  var s = 0;
+  for (var k in m) {
+    if (hasOwnProperty.call(m, k)) {
+      ++s;
+    }
+  }
+  return s;
+}
+
+export function _lookup(no, yes, k, m) {
+  return k in m ? yes(m[k]) : no;
+}
+
+export function _lookupST(no, yes, k, m) {
+  return function () {
+    return k in m ? yes(m[k]) : no;
+  };
+}
+
+export function toArrayWithKey(f) {
+  return function (m) {
+    var r = [];
+    for (var k in m) {
+      if (hasOwnProperty.call(m, k)) {
+        r.push(f(k)(m[k]));
+      }
+    }
+    return r;
+  };
+}
+
+export const keys = Object.keys || toArrayWithKey(function (k) {
+  return function () { return k; };
+});

package/output-es/Foreign.Object/index.js

@@ -0,0 +1,304 @@
+// | This module defines a type of native homogeneous Javascript Objects.
+// |
+// | To maximize performance, Javascript objects are not wrapped,
+// | and some native code is used even when it's not necessary.
+import * as $runtime from "../runtime.js";
+import * as Control$dMonad$dST$dInternal from "../Control.Monad.ST.Internal/index.js";
+import * as Data$dArray from "../Data.Array/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFoldableWithIndex from "../Data.FoldableWithIndex/index.js";
+import * as Data$dFunction from "../Data.Function/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Data$dUnfoldable from "../Data.Unfoldable/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+import {_copyST, _fmapObject, _foldM, _foldSCObject, _lookup, _lookupST, _mapWithKey, all, empty, keys, runST, size, toArrayWithKey} from "./foreign.js";
+const showTuple = dictShow1 => ({show: v => "(Tuple " + Data$dShow.showStringImpl(v._1) + " " + dictShow1.show(v._2) + ")"});
+const forWithIndex_ = /* #__PURE__ */ Data$dFoldableWithIndex.forWithIndex_(Control$dMonad$dST$dInternal.applicativeST);
+const for_ = /* #__PURE__ */ Data$dFoldable.for_(Control$dMonad$dST$dInternal.applicativeST);
+const identity = x => x;
+const ordTuple = dictOrd1 => {
+  const $0 = dictOrd1.Eq0();
+  const eqTuple2 = {eq: x => y => x._1 === y._1 && $0.eq(x._2)(y._2)};
+  return {
+    compare: x => y => {
+      const v = Data$dOrd.ordString.compare(x._1)(y._1);
+      if (v === "LT") { return Data$dOrdering.LT; }
+      if (v === "GT") { return Data$dOrdering.GT; }
+      return dictOrd1.compare(x._2)(y._2);
+    },
+    Eq0: () => eqTuple2
+  };
+};
+const values = /* #__PURE__ */ toArrayWithKey(v => v1 => v1);
+const toUnfoldable = dictUnfoldable => {
+  const $0 = toArrayWithKey(Data$dTuple.Tuple);
+  return x => {
+    const $1 = $0(x);
+    const len = $1.length;
+    return dictUnfoldable.unfoldr(i => {
+      if (i < len) { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple($1[i], i + 1 | 0)); }
+      return Data$dMaybe.Nothing;
+    })(0);
+  };
+};
+const toAscUnfoldable = dictUnfoldable => {
+  const $0 = toArrayWithKey(Data$dTuple.Tuple);
+  return x => {
+    const $1 = Data$dArray.sortWith(Data$dOrd.ordString)(Data$dTuple.fst)($0(x));
+    const len = $1.length;
+    return dictUnfoldable.unfoldr(i => {
+      if (i < len) { return Data$dMaybe.$Maybe("Just", Data$dTuple.$Tuple($1[i], i + 1 | 0)); }
+      return Data$dMaybe.Nothing;
+    })(0);
+  };
+};
+const toAscArray = /* #__PURE__ */ toAscUnfoldable(Data$dUnfoldable.unfoldableArray);
+const toArray = /* #__PURE__ */ toArrayWithKey(Data$dTuple.Tuple);
+const thawST = _copyST;
+const singleton = k => v => {
+  const $0 = {};
+  $0[k] = v;
+  return $0;
+};
+const showObject = dictShow => {
+  const show = Data$dShow.showArrayImpl(showTuple(dictShow).show);
+  return {show: m => "(fromFoldable " + show(toArray(m)) + ")"};
+};
+const mutate = f => m => {
+  const s = {...m};
+  f(s)();
+  return s;
+};
+const member = $0 => $1 => _lookup(false, v => true, $0, $1);
+const mapWithKey = f => m => _mapWithKey(m, f);
+const lookup = $0 => $1 => _lookup(Data$dMaybe.Nothing, Data$dMaybe.Just, $0, $1);
+const isSubmap = dictEq => m1 => m2 => all(k => v => _lookup(false, dictEq.eq(v), k, m2))(m1);
+const isEmpty = /* #__PURE__ */ all(v => v1 => false);
+const insert = k => v => mutate($0 => () => {
+  $0[k] = v;
+  return $0;
+});
+const functorObject = {map: f => m => _fmapObject(m, f)};
+const functorWithIndexObject = {mapWithIndex: mapWithKey, Functor0: () => functorObject};
+const fromHomogeneous = () => Unsafe$dCoerce.unsafeCoerce;
+const fromFoldableWithIndex = dictFoldableWithIndex => {
+  const forWithIndex_1 = forWithIndex_(dictFoldableWithIndex);
+  return l => {
+    const s = {};
+    forWithIndex_1(l)(k => v => () => {
+      s[k] = v;
+      return s;
+    })();
+    return s;
+  };
+};
+const fromFoldableWith = dictFoldable => {
+  const for_1 = for_(dictFoldable);
+  return f => l => {
+    const s = {};
+    for_1(l)(v => {
+      const $0 = v._1;
+      const $1 = _lookupST(v._2, f(v._2), $0, s);
+      return () => {
+        const v$p = $1();
+        s[$0] = v$p;
+        return s;
+      };
+    })();
+    return s;
+  };
+};
+const fromFoldable = dictFoldable => {
+  const $0 = dictFoldable.foldr;
+  return l => {
+    const s = {};
+    for (const v of Data$dArray.fromFoldableImpl($0, l)) {
+      s[v._1] = v._2;
+    }
+    return s;
+  };
+};
+const freezeST = _copyST;
+const foldMaybe = f => z => m => _foldSCObject(m, z, f, Data$dMaybe.fromMaybe);
+const foldM = dictMonad => {
+  const bind1 = dictMonad.Bind1().bind;
+  return f => z => _foldM(bind1)(f)(dictMonad.Applicative0().pure(z));
+};
+const foldM1 = /* #__PURE__ */ foldM(Control$dMonad$dST$dInternal.monadST);
+const union = m => mutate(s => foldM1(s$p => k => v => () => {
+  s$p[k] = v;
+  return s$p;
+})(s)(m));
+const unions = dictFoldable => dictFoldable.foldl(union)(empty);
+const unionWith = f => m1 => m2 => mutate(s1 => foldM1(s2 => k => v1 => {
+  const $0 = _lookup(v1, v2 => f(v1)(v2), k, m2);
+  return () => {
+    s2[k] = $0;
+    return s2;
+  };
+})(s1)(m1))(m2);
+const semigroupObject = dictSemigroup => ({append: unionWith(dictSemigroup.append)});
+const monoidObject = dictSemigroup => ({mempty: empty, Semigroup0: () => ({append: unionWith(dictSemigroup.append)})});
+const fold = /* #__PURE__ */ _foldM(Data$dFunction.applyFlipped);
+const foldMap = dictMonoid => {
+  const mempty = dictMonoid.mempty;
+  return f => fold(acc => k => v => dictMonoid.Semigroup0().append(acc)(f(k)(v)))(mempty);
+};
+const foldableObject = {
+  foldl: f => fold(z => v => f(z)),
+  foldr: f => z => m => Data$dFoldable.foldrArray(f)(z)(values(m)),
+  foldMap: dictMonoid => {
+    const foldMap1 = foldMap(dictMonoid);
+    return f => foldMap1(v => f);
+  }
+};
+const foldableWithIndexObject = {
+  foldlWithIndex: f => fold(b => a => f(a)(b)),
+  foldrWithIndex: f => z => m => Data$dFoldable.foldrArray(v => f(v._1)(v._2))(z)(toArrayWithKey(Data$dTuple.Tuple)(m)),
+  foldMapWithIndex: dictMonoid => foldMap(dictMonoid),
+  Foldable0: () => foldableObject
+};
+const traversableWithIndexObject = {
+  traverseWithIndex: dictApplicative => {
+    const Apply0 = dictApplicative.Apply0();
+    return f => ms => fold(acc => k => v => Apply0.apply(Apply0.Functor0().map(b => a => mutate($0 => () => {
+      $0[k] = a;
+      return $0;
+    })(b))(acc))(f(k)(v)))(dictApplicative.pure(empty))(ms);
+  },
+  FunctorWithIndex0: () => functorWithIndexObject,
+  FoldableWithIndex1: () => foldableWithIndexObject,
+  Traversable2: () => traversableObject
+};
+const traversableObject = {
+  traverse: dictApplicative => {
+    const $0 = traversableWithIndexObject.traverseWithIndex(dictApplicative);
+    return x => $0(v => x);
+  },
+  sequence: dictApplicative => traversableObject.traverse(dictApplicative)(identity),
+  Functor0: () => functorObject,
+  Foldable1: () => foldableObject
+};
+const filterWithKey = predicate => m => {
+  const m$p = {};
+  return foldM1(acc => k => v => {
+    if (predicate(k)(v)) {
+      return () => {
+        acc[k] = v;
+        return acc;
+      };
+    }
+    return () => acc;
+  })(m$p)(m)();
+};
+const filterKeys = predicate => filterWithKey(x => {
+  const $0 = predicate(x);
+  return v => $0;
+});
+const filter = predicate => filterWithKey(v => predicate);
+const eqObject = dictEq => ({eq: m1 => m2 => isSubmap(dictEq)(m1)(m2) && isSubmap(dictEq)(m2)(m1)});
+const ordObject = dictOrd => {
+  const eqObject1 = eqObject(dictOrd.Eq0());
+  return {compare: m1 => m2 => Data$dOrd.ordArray(ordTuple(dictOrd)).compare(toAscArray(m1))(toAscArray(m2)), Eq0: () => eqObject1};
+};
+const eq1Object = {eq1: dictEq => eqObject(dictEq).eq};
+const $$delete = k => mutate($0 => () => {
+  delete $0[k];
+  return $0;
+});
+const pop = k => m => {
+  const $0 = _lookup(Data$dMaybe.Nothing, Data$dMaybe.Just, k, m);
+  if ($0.tag === "Just") {
+    return Data$dMaybe.$Maybe(
+      "Just",
+      Data$dTuple.$Tuple(
+        $0._1,
+        mutate($1 => () => {
+          delete $1[k];
+          return $1;
+        })(m)
+      )
+    );
+  }
+  return Data$dMaybe.Nothing;
+};
+const alter = f => k => m => {
+  const v = f(_lookup(Data$dMaybe.Nothing, Data$dMaybe.Just, k, m));
+  if (v.tag === "Nothing") {
+    return mutate($0 => () => {
+      delete $0[k];
+      return $0;
+    })(m);
+  }
+  if (v.tag === "Just") {
+    const $0 = v._1;
+    return mutate($1 => () => {
+      $1[k] = $0;
+      return $1;
+    })(m);
+  }
+  $runtime.fail();
+};
+const update = f => k => m => alter(v2 => {
+  if (v2.tag === "Nothing") { return Data$dMaybe.Nothing; }
+  if (v2.tag === "Just") { return f(v2._1); }
+  $runtime.fail();
+})(k)(m);
+export {
+  alter,
+  $$delete as delete,
+  eq1Object,
+  eqObject,
+  filter,
+  filterKeys,
+  filterWithKey,
+  fold,
+  foldM,
+  foldM1,
+  foldMap,
+  foldMaybe,
+  foldableObject,
+  foldableWithIndexObject,
+  forWithIndex_,
+  for_,
+  freezeST,
+  fromFoldable,
+  fromFoldableWith,
+  fromFoldableWithIndex,
+  fromHomogeneous,
+  functorObject,
+  functorWithIndexObject,
+  identity,
+  insert,
+  isEmpty,
+  isSubmap,
+  lookup,
+  mapWithKey,
+  member,
+  monoidObject,
+  mutate,
+  ordObject,
+  ordTuple,
+  pop,
+  semigroupObject,
+  showObject,
+  showTuple,
+  singleton,
+  thawST,
+  toArray,
+  toAscArray,
+  toAscUnfoldable,
+  toUnfoldable,
+  traversableObject,
+  traversableWithIndexObject,
+  union,
+  unionWith,
+  unions,
+  update,
+  values
+};
+export * from "./foreign.js";

package/output-es/Foreign.Object.Gen/index.js

@@ -0,0 +1,13 @@
+import * as Control$dMonad$dGen from "../Control.Monad.Gen/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+const fromFoldable = /* #__PURE__ */ Foreign$dObject.fromFoldable(Data$dList$dTypes.foldableList);
+const genForeignObject = dictMonadRec => dictMonadGen => {
+  const Bind1 = dictMonadGen.Monad0().Bind1();
+  const Apply0 = Bind1.Apply0();
+  const $0 = Apply0.Functor0();
+  const unfoldable1 = Control$dMonad$dGen.unfoldable(dictMonadRec)(dictMonadGen)(Data$dList$dTypes.unfoldableList);
+  return genKey => genValue => dictMonadGen.sized(size => Bind1.bind(dictMonadGen.chooseInt(0)(size))(newSize => dictMonadGen.resize(v => newSize)($0.map(fromFoldable)(unfoldable1(Apply0.apply($0.map(Data$dTuple.Tuple)(genKey))(genValue))))));
+};
+export {fromFoldable, genForeignObject};

package/output-es/Foreign.Object.ST/foreign.js

@@ -0,0 +1,37 @@
+const newImpl = function () {
+  return {};
+};
+export { newImpl as new };
+
+export function peekImpl(just) {
+  return function (nothing) {
+    return function (k) {
+      return function (m) {
+        return function () {
+          return {}.hasOwnProperty.call(m, k) ? just(m[k]) : nothing;
+        };
+      };
+    };
+  };
+}
+
+export function poke(k) {
+  return function (v) {
+    return function (m) {
+      return function () {
+        m[k] = v;
+        return m;
+      };
+    };
+  };
+}
+
+const deleteImpl = function (k) {
+  return function (m) {
+    return function () {
+      delete m[k];
+      return m;
+    };
+  };
+};
+export { deleteImpl as delete };

package/output-es/Foreign.Object.ST/index.js

@@ -0,0 +1,9 @@
+// | Helper functions for working with mutable objects using the `ST` effect.
+// |
+// | This module can be used when performance is important and mutation is a
+// | local effect.
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import {delete as $$delete, new as $$new, peekImpl, poke} from "./foreign.js";
+const peek = /* #__PURE__ */ peekImpl(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+export {peek};
+export * from "./foreign.js";

package/output-es/Foreign.Object.ST.Unsafe/foreign.js

@@ -0,0 +1,5 @@
+export function unsafeFreeze(m) {
+  return function () {
+    return m;
+  };
+}

package/output-es/Foreign.Object.ST.Unsafe/index.js

@@ -0,0 +1,3 @@
+import {unsafeFreeze} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/Foreign.Object.Unsafe/foreign.js

@@ -0,0 +1,5 @@
+export function unsafeIndex(m) {
+  return function (k) {
+    return m[k];
+  };
+}

package/output-es/Foreign.Object.Unsafe/index.js

@@ -0,0 +1,3 @@
+import {unsafeIndex} from "./foreign.js";
+export {};
+export * from "./foreign.js";

package/output-es/GaloisConnection/index.js

@@ -0,0 +1,72 @@
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Util from "../Util/index.js";
+const identity = x => x;
+const GC = x => x;
+const semigroupoidGaloisConnect = {compose: v => v1 => ({fwd: x => v.fwd(v1.fwd(x)), bwd: x => v1.bwd(v.bwd(x))})};
+const newtypeGaloisConnection_ = {Coercible0: () => {}};
+const categoryGaloisConnection = {identity: {fwd: identity, bwd: identity}, Semigroupoid0: () => semigroupoidGaloisConnect};
+const unsnd = dictBoundedMeetSemilattice => {
+  const top = dictBoundedMeetSemilattice.top;
+  return {fwd: b => Data$dTuple.$Tuple(top, b), bwd: Data$dTuple.snd};
+};
+const unfst = dictBoundedMeetSemilattice => {
+  const top = dictBoundedMeetSemilattice.top;
+  return {fwd: a => Data$dTuple.$Tuple(a, top), bwd: Data$dTuple.fst};
+};
+const splitStrong = v => v1 => ({fwd: x => Data$dTuple.$Tuple(v.fwd(x._1), v1.fwd(x._2)), bwd: x => Data$dTuple.$Tuple(v.bwd(x._1), v1.bwd(x._2))});
+const second = v => (
+  {fwd: x => Data$dTuple.$Tuple(categoryGaloisConnection.identity.fwd(x._1), v.fwd(x._2)), bwd: x => Data$dTuple.$Tuple(categoryGaloisConnection.identity.bwd(x._1), v.bwd(x._2))}
+);
+const join = dictJoinSemilattice => ({fwd: Util.dup, bwd: v => dictJoinSemilattice.join(v._1)(v._2)});
+const first = v => (
+  {fwd: x => Data$dTuple.$Tuple(v.fwd(x._1), categoryGaloisConnection.identity.fwd(x._2)), bwd: x => Data$dTuple.$Tuple(v.bwd(x._1), categoryGaloisConnection.identity.bwd(x._2))}
+);
+const fanout = dictNeg => dictJoinSemilattice => f => g => ({fwd: x => Data$dTuple.$Tuple(f.fwd(x), g.fwd(x)), bwd: x => dictJoinSemilattice.join(f.bwd(x._1))(g.bwd(x._2))});
+const deMorgan = dictNeg => dictNeg1 => x => x$1 => dictNeg1.neg(x(dictNeg.neg(x$1)));
+const dual = dictNeg => dictNeg1 => v => ({fwd: x => dictNeg.neg(v.bwd(dictNeg1.neg(x))), bwd: x => dictNeg1.neg(v.fwd(dictNeg.neg(x)))});
+const meet = dictNeg => dictJoinSemilattice => (
+  {
+    fwd: x => dictNeg.neg(dictJoinSemilattice.join(dictNeg.neg(x._1))(dictNeg.neg(x._2))),
+    bwd: x => {
+      const $0 = dictNeg.neg(x);
+      return Data$dTuple.$Tuple(dictNeg.neg($0), dictNeg.neg($0));
+    }
+  }
+);
+const relatedInputs = dictNeg => dictNeg1 => dictJoinSemilattice => f => (
+  {
+    fwd: x => dictNeg.neg(f.bwd(dictNeg1.neg(dictNeg1.neg(dictJoinSemilattice.join(dictNeg1.neg(f.fwd(x._1)))(dictNeg1.neg(categoryGaloisConnection.identity.fwd(x._2))))))),
+    bwd: x => {
+      const $0 = dictNeg1.neg(dictNeg1.neg(f.fwd(dictNeg.neg(x))));
+      return Data$dTuple.$Tuple(f.bwd(dictNeg1.neg($0)), categoryGaloisConnection.identity.bwd(dictNeg1.neg($0)));
+    }
+  }
+);
+const relatedOutputs = dictNeg => dictJoinSemilattice => dictNeg1 => f => (
+  {
+    fwd: x => f.fwd(dictNeg.neg(dictJoinSemilattice.join(dictNeg.neg(dictNeg.neg(f.bwd(dictNeg1.neg(x._1)))))(dictNeg.neg(categoryGaloisConnection.identity.fwd(x._2))))),
+    bwd: x => {
+      const $0 = dictNeg.neg(f.bwd(x));
+      return Data$dTuple.$Tuple(dictNeg1.neg(f.fwd(dictNeg.neg(dictNeg.neg($0)))), categoryGaloisConnection.identity.bwd(dictNeg.neg($0)));
+    }
+  }
+);
+export {
+  GC,
+  categoryGaloisConnection,
+  deMorgan,
+  dual,
+  fanout,
+  first,
+  identity,
+  join,
+  meet,
+  newtypeGaloisConnection_,
+  relatedInputs,
+  relatedOutputs,
+  second,
+  semigroupoidGaloisConnect,
+  splitStrong,
+  unfst,
+  unsnd
+};