@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,370 @@
+// | A data structure and functions for graphs
+import * as $runtime from "../runtime.js";
+import * as Data$dCatList from "../Data.CatList/index.js";
+import * as Data$dCatQueue from "../Data.CatQueue/index.js";
+import * as Data$dFoldable from "../Data.Foldable/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$dTuple from "../Data.Tuple/index.js";
+const $SortStep = (tag, _1) => ({tag, _1});
+const fromFoldable = /* #__PURE__ */ (() => {
+  const foldMap1 = Data$dList$dTypes.foldableList.foldMap(Data$dCatList.monoidCatList);
+  return f => foldMap1(Data$dCatList.singleton)(f);
+})();
+const fromFoldable1 = /* #__PURE__ */ (() => {
+  const foldMap1 = Data$dFoldable.foldableArray.foldMap(Data$dCatList.monoidCatList);
+  return f => foldMap1(Data$dCatList.singleton)(f);
+})();
+const identity = x => x;
+const Emit = value0 => $SortStep("Emit", value0);
+const Visit = value0 => $SortStep("Visit", value0);
+const Graph = x => x;
+const vertices = v => Data$dList$dTypes.listMap(Data$dTuple.fst)((() => {
+  const go = (m$p, z$p) => {
+    if (m$p.tag === "Leaf") { return z$p; }
+    if (m$p.tag === "Node") { return go(m$p._5, Data$dList$dTypes.$List("Cons", m$p._4, go(m$p._6, z$p))); }
+    $runtime.fail();
+  };
+  return go(v, Data$dList$dTypes.Nil);
+})());
+const unfoldGraph = dictOrd => dictFunctor => dictFoldable => {
+  const fromFoldable3 = Data$dMap$dInternal.fromFoldable(dictOrd)(dictFoldable);
+  return dictFoldable1 => {
+    const fromFoldable4 = dictFoldable1.foldr(Data$dList$dTypes.Cons)(Data$dList$dTypes.Nil);
+    return ks => label => theEdges => fromFoldable3(dictFunctor.map(k => Data$dTuple.$Tuple(k, Data$dTuple.$Tuple(label(k), fromFoldable4(theEdges(k)))))(ks));
+  };
+};
+const topologicalSort = dictOrd => v => {
+  const visit = visit$a0$copy => visit$a1$copy => {
+    let visit$a0 = visit$a0$copy, visit$a1 = visit$a1$copy, visit$c = true, visit$r;
+    while (visit$c) {
+      const state = visit$a0, stack = visit$a1;
+      const v1 = Data$dCatList.uncons(stack);
+      if (v1.tag === "Nothing") {
+        visit$c = false;
+        visit$r = state;
+        continue;
+      }
+      if (v1.tag === "Just") {
+        if (v1._1._1.tag === "Emit") {
+          visit$a0 = {result: Data$dList$dTypes.$List("Cons", v1._1._1._1, state.result), unvisited: state.unvisited};
+          visit$a1 = v1._1._2;
+          continue;
+        }
+        if (v1._1._1.tag === "Visit") {
+          if (
+            (() => {
+              const $0 = v1._1._1._1;
+              const go = go$a0$copy => {
+                let go$a0 = go$a0$copy, go$c = true, go$r;
+                while (go$c) {
+                  const v$1 = go$a0;
+                  if (v$1.tag === "Leaf") {
+                    go$c = false;
+                    go$r = false;
+                    continue;
+                  }
+                  if (v$1.tag === "Node") {
+                    const v1$1 = dictOrd.compare($0)(v$1._3);
+                    if (v1$1 === "LT") {
+                      go$a0 = v$1._5;
+                      continue;
+                    }
+                    if (v1$1 === "GT") {
+                      go$a0 = v$1._6;
+                      continue;
+                    }
+                    if (v1$1 === "EQ") {
+                      go$c = false;
+                      go$r = true;
+                      continue;
+                    }
+                  }
+                  $runtime.fail();
+                }
+                return go$r;
+              };
+              return go(state.unvisited);
+            })()
+          ) {
+            const $0 = v1._1._1._1;
+            visit$a0 = {result: state.result, unvisited: Data$dMap$dInternal.delete(dictOrd)($0)(state.unvisited)};
+            visit$a1 = (() => {
+              const $1 = fromFoldable(Data$dList$dTypes.listMap(Visit)((() => {
+                const go = go$a0$copy => {
+                  let go$a0 = go$a0$copy, go$c = true, go$r;
+                  while (go$c) {
+                    const v$1 = go$a0;
+                    if (v$1.tag === "Leaf") {
+                      go$c = false;
+                      go$r = Data$dMaybe.Nothing;
+                      continue;
+                    }
+                    if (v$1.tag === "Node") {
+                      const v1$1 = dictOrd.compare($0)(v$1._3);
+                      if (v1$1 === "LT") {
+                        go$a0 = v$1._5;
+                        continue;
+                      }
+                      if (v1$1 === "GT") {
+                        go$a0 = v$1._6;
+                        continue;
+                      }
+                      if (v1$1 === "EQ") {
+                        go$c = false;
+                        go$r = Data$dMaybe.$Maybe("Just", v$1._4);
+                        continue;
+                      }
+                    }
+                    $runtime.fail();
+                  }
+                  return go$r;
+                };
+                const $1 = go(v);
+                if ($1.tag === "Nothing") { return Data$dList$dTypes.Nil; }
+                if ($1.tag === "Just") { return $1._1._2; }
+                $runtime.fail();
+              })()));
+              const $2 = v1._1._2.tag === "CatNil"
+                ? Data$dCatList.$CatList("CatCons", $SortStep("Emit", $0), Data$dCatQueue.$CatQueue(Data$dList$dTypes.Nil, Data$dList$dTypes.Nil))
+                : Data$dCatList.$CatList(
+                    "CatCons",
+                    $SortStep("Emit", $0),
+                    Data$dCatQueue.$CatQueue(Data$dList$dTypes.Nil, Data$dList$dTypes.$List("Cons", v1._1._2, Data$dList$dTypes.Nil))
+                  );
+              if ($1.tag === "CatNil") { return $2; }
+              if ($2.tag === "CatNil") { return $1; }
+              if ($1.tag === "CatCons") { return Data$dCatList.$CatList("CatCons", $1._1, Data$dCatQueue.$CatQueue($1._2._1, Data$dList$dTypes.$List("Cons", $2, $1._2._2))); }
+              $runtime.fail();
+            })();
+            continue;
+          }
+          visit$a0 = state;
+          visit$a1 = v1._1._2;
+          continue;
+        }
+      }
+      $runtime.fail();
+    }
+    return visit$r;
+  };
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v1 = go$a0;
+      const v2 = Data$dMap$dInternal.findMin(v1.unvisited);
+      if (v2.tag === "Just") {
+        go$a0 = visit(v1)(fromFoldable1([$SortStep("Visit", v2._1.key)]));
+        continue;
+      }
+      if (v2.tag === "Nothing") {
+        go$c = false;
+        go$r = v1.result;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  return go({unvisited: v, result: Data$dList$dTypes.Nil});
+};
+const toMap = v => v;
+const outEdges = dictOrd => k => v => {
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v$1 = go$a0;
+      if (v$1.tag === "Leaf") {
+        go$c = false;
+        go$r = Data$dMaybe.Nothing;
+        continue;
+      }
+      if (v$1.tag === "Node") {
+        const v1 = dictOrd.compare(k)(v$1._3);
+        if (v1 === "LT") {
+          go$a0 = v$1._5;
+          continue;
+        }
+        if (v1 === "GT") {
+          go$a0 = v$1._6;
+          continue;
+        }
+        if (v1 === "EQ") {
+          go$c = false;
+          go$r = Data$dMaybe.$Maybe("Just", v$1._4);
+          continue;
+        }
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const $0 = go(v);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0._1._2); }
+  return Data$dMaybe.Nothing;
+};
+const lookup = dictOrd => k => v => {
+  const go = go$a0$copy => {
+    let go$a0 = go$a0$copy, go$c = true, go$r;
+    while (go$c) {
+      const v$1 = go$a0;
+      if (v$1.tag === "Leaf") {
+        go$c = false;
+        go$r = Data$dMaybe.Nothing;
+        continue;
+      }
+      if (v$1.tag === "Node") {
+        const v1 = dictOrd.compare(k)(v$1._3);
+        if (v1 === "LT") {
+          go$a0 = v$1._5;
+          continue;
+        }
+        if (v1 === "GT") {
+          go$a0 = v$1._6;
+          continue;
+        }
+        if (v1 === "EQ") {
+          go$c = false;
+          go$r = Data$dMaybe.$Maybe("Just", v$1._4);
+          continue;
+        }
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const $0 = go(v);
+  if ($0.tag === "Just") { return Data$dMaybe.$Maybe("Just", $0._1._1); }
+  return Data$dMaybe.Nothing;
+};
+const functorGraph = {
+  map: f => v => {
+    const go = v$1 => {
+      if (v$1.tag === "Leaf") { return Data$dMap$dInternal.Leaf; }
+      if (v$1.tag === "Node") { return Data$dMap$dInternal.$$$Map("Node", v$1._1, v$1._2, v$1._3, Data$dTuple.$Tuple(f(v$1._4._1), v$1._4._2), go(v$1._5), go(v$1._6)); }
+      $runtime.fail();
+    };
+    return go(v);
+  }
+};
+const fromMap = Graph;
+const foldableGraph = {
+  foldl: f => z => v => {
+    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$1 = go$a1;
+        if (v$1.tag === "Nil") {
+          go$c = false;
+          go$r = b;
+          continue;
+        }
+        if (v$1.tag === "Cons") {
+          go$a0 = f(b)(v$1._1._1);
+          go$a1 = v$1._2;
+          continue;
+        }
+        $runtime.fail();
+      }
+      return go$r;
+    };
+    return go(z)((() => {
+      const go$1 = (m$p, z$p) => {
+        if (m$p.tag === "Leaf") { return z$p; }
+        if (m$p.tag === "Node") { return go$1(m$p._5, Data$dList$dTypes.$List("Cons", m$p._4, go$1(m$p._6, z$p))); }
+        $runtime.fail();
+      };
+      return go$1(v, Data$dList$dTypes.Nil);
+    })());
+  },
+  foldr: f => z => v => Data$dList$dTypes.foldableList.foldr(v1 => {
+    const $0 = v1._1;
+    return acc => f($0)(acc);
+  })(z)((() => {
+    const go = (m$p, z$p) => {
+      if (m$p.tag === "Leaf") { return z$p; }
+      if (m$p.tag === "Node") { return go(m$p._5, Data$dList$dTypes.$List("Cons", m$p._4, go(m$p._6, z$p))); }
+      $runtime.fail();
+    };
+    return go(v, Data$dList$dTypes.Nil);
+  })()),
+  foldMap: dictMonoid => {
+    const foldMap1 = Data$dList$dTypes.foldableList.foldMap(dictMonoid);
+    return f => v => foldMap1(x => f(x._1))((() => {
+      const go = (m$p, z$p) => {
+        if (m$p.tag === "Leaf") { return z$p; }
+        if (m$p.tag === "Node") { return go(m$p._5, Data$dList$dTypes.$List("Cons", m$p._4, go(m$p._6, z$p))); }
+        $runtime.fail();
+      };
+      return go(v, Data$dList$dTypes.Nil);
+    })());
+  }
+};
+const traversableGraph = {
+  traverse: dictApplicative => {
+    const $0 = dictApplicative.Apply0().Functor0();
+    const traverse1 = Data$dMap$dInternal.traversableMap.traverse(dictApplicative);
+    return f => v => $0.map(Graph)(traverse1(v1 => {
+      const $1 = v1._2;
+      return $0.map(v3 => Data$dTuple.$Tuple(v3, $1))(f(v1._1));
+    })(v));
+  },
+  sequence: dictApplicative => traversableGraph.traverse(dictApplicative)(identity),
+  Functor0: () => functorGraph,
+  Foldable1: () => foldableGraph
+};
+const edges = v => {
+  const go = (z$p, m$p) => {
+    if (m$p.tag === "Leaf") { return z$p; }
+    if (m$p.tag === "Node") {
+      return go(
+        (() => {
+          const $0 = m$p._3;
+          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", {start: $0, end: v$1._1}, b);
+                go$1$a1 = v$1._2;
+                continue;
+              }
+              $runtime.fail();
+            }
+            return go$1$r;
+          };
+          return go$1(go(z$p, m$p._5))(m$p._4._2);
+        })(),
+        m$p._6
+      );
+    }
+    $runtime.fail();
+  };
+  return go(Data$dList$dTypes.Nil, v);
+};
+export {
+  $SortStep,
+  Emit,
+  Graph,
+  Visit,
+  edges,
+  foldableGraph,
+  fromFoldable,
+  fromFoldable1,
+  fromMap,
+  functorGraph,
+  identity,
+  lookup,
+  outEdges,
+  toMap,
+  topologicalSort,
+  traversableGraph,
+  unfoldGraph,
+  vertices
+};

package/output-es/Data.HTTP.Method/index.js

@@ -0,0 +1,223 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/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$dString$dCommon from "../Data.String.Common/index.js";
+const $Method = tag => tag;
+const OPTIONS = /* #__PURE__ */ $Method("OPTIONS");
+const GET = /* #__PURE__ */ $Method("GET");
+const HEAD = /* #__PURE__ */ $Method("HEAD");
+const POST = /* #__PURE__ */ $Method("POST");
+const PUT = /* #__PURE__ */ $Method("PUT");
+const DELETE = /* #__PURE__ */ $Method("DELETE");
+const TRACE = /* #__PURE__ */ $Method("TRACE");
+const CONNECT = /* #__PURE__ */ $Method("CONNECT");
+const PROPFIND = /* #__PURE__ */ $Method("PROPFIND");
+const PROPPATCH = /* #__PURE__ */ $Method("PROPPATCH");
+const MKCOL = /* #__PURE__ */ $Method("MKCOL");
+const COPY = /* #__PURE__ */ $Method("COPY");
+const MOVE = /* #__PURE__ */ $Method("MOVE");
+const LOCK = /* #__PURE__ */ $Method("LOCK");
+const UNLOCK = /* #__PURE__ */ $Method("UNLOCK");
+const PATCH = /* #__PURE__ */ $Method("PATCH");
+const unCustomMethod = v => v;
+const showMethod = {
+  show: v => {
+    if (v === "OPTIONS") { return "OPTIONS"; }
+    if (v === "GET") { return "GET"; }
+    if (v === "HEAD") { return "HEAD"; }
+    if (v === "POST") { return "POST"; }
+    if (v === "PUT") { return "PUT"; }
+    if (v === "DELETE") { return "DELETE"; }
+    if (v === "TRACE") { return "TRACE"; }
+    if (v === "CONNECT") { return "CONNECT"; }
+    if (v === "PROPFIND") { return "PROPFIND"; }
+    if (v === "PROPPATCH") { return "PROPPATCH"; }
+    if (v === "MKCOL") { return "MKCOL"; }
+    if (v === "COPY") { return "COPY"; }
+    if (v === "MOVE") { return "MOVE"; }
+    if (v === "LOCK") { return "LOCK"; }
+    if (v === "UNLOCK") { return "UNLOCK"; }
+    if (v === "PATCH") { return "PATCH"; }
+    $runtime.fail();
+  }
+};
+const showCustomMethod = {show: v => "(CustomMethod " + Data$dShow.showStringImpl(v) + ")"};
+const print = v2 => {
+  if (v2.tag === "Left") {
+    if (v2._1 === "OPTIONS") { return "OPTIONS"; }
+    if (v2._1 === "GET") { return "GET"; }
+    if (v2._1 === "HEAD") { return "HEAD"; }
+    if (v2._1 === "POST") { return "POST"; }
+    if (v2._1 === "PUT") { return "PUT"; }
+    if (v2._1 === "DELETE") { return "DELETE"; }
+    if (v2._1 === "TRACE") { return "TRACE"; }
+    if (v2._1 === "CONNECT") { return "CONNECT"; }
+    if (v2._1 === "PROPFIND") { return "PROPFIND"; }
+    if (v2._1 === "PROPPATCH") { return "PROPPATCH"; }
+    if (v2._1 === "MKCOL") { return "MKCOL"; }
+    if (v2._1 === "COPY") { return "COPY"; }
+    if (v2._1 === "MOVE") { return "MOVE"; }
+    if (v2._1 === "LOCK") { return "LOCK"; }
+    if (v2._1 === "UNLOCK") { return "UNLOCK"; }
+    if (v2._1 === "PATCH") { return "PATCH"; }
+    $runtime.fail();
+  }
+  if (v2.tag === "Right") { return v2._1; }
+  $runtime.fail();
+};
+const parse = handleMethod => handleUnknown => s => {
+  const v = Data$dString$dCommon.toUpper(s);
+  if (v === "OPTIONS") { return handleMethod(OPTIONS); }
+  if (v === "GET") { return handleMethod(GET); }
+  if (v === "HEAD") { return handleMethod(HEAD); }
+  if (v === "POST") { return handleMethod(POST); }
+  if (v === "PUT") { return handleMethod(PUT); }
+  if (v === "DELETE") { return handleMethod(DELETE); }
+  if (v === "TRACE") { return handleMethod(TRACE); }
+  if (v === "CONNECT") { return handleMethod(CONNECT); }
+  if (v === "PROPFIND") { return handleMethod(PROPFIND); }
+  if (v === "PROPPATCH") { return handleMethod(PROPPATCH); }
+  if (v === "MKCOL") { return handleMethod(MKCOL); }
+  if (v === "COPY") { return handleMethod(COPY); }
+  if (v === "MOVE") { return handleMethod(MOVE); }
+  if (v === "LOCK") { return handleMethod(LOCK); }
+  if (v === "UNLOCK") { return handleMethod(UNLOCK); }
+  if (v === "PATCH") { return handleMethod(PATCH); }
+  return handleUnknown(v);
+};
+const fromString = /* #__PURE__ */ parse(Data$dEither.Left)(x => Data$dEither.$Either("Right", x));
+const eqMethod = {
+  eq: x => y => {
+    if (x === "OPTIONS") { return y === "OPTIONS"; }
+    if (x === "GET") { return y === "GET"; }
+    if (x === "HEAD") { return y === "HEAD"; }
+    if (x === "POST") { return y === "POST"; }
+    if (x === "PUT") { return y === "PUT"; }
+    if (x === "DELETE") { return y === "DELETE"; }
+    if (x === "TRACE") { return y === "TRACE"; }
+    if (x === "CONNECT") { return y === "CONNECT"; }
+    if (x === "PROPFIND") { return y === "PROPFIND"; }
+    if (x === "PROPPATCH") { return y === "PROPPATCH"; }
+    if (x === "MKCOL") { return y === "MKCOL"; }
+    if (x === "COPY") { return y === "COPY"; }
+    if (x === "MOVE") { return y === "MOVE"; }
+    if (x === "LOCK") { return y === "LOCK"; }
+    if (x === "UNLOCK") { return y === "UNLOCK"; }
+    return x === "PATCH" && y === "PATCH";
+  }
+};
+const ordMethod = {
+  compare: x => y => {
+    if (x === "OPTIONS") {
+      if (y === "OPTIONS") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "OPTIONS") { return Data$dOrdering.GT; }
+    if (x === "GET") {
+      if (y === "GET") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "GET") { return Data$dOrdering.GT; }
+    if (x === "HEAD") {
+      if (y === "HEAD") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "HEAD") { return Data$dOrdering.GT; }
+    if (x === "POST") {
+      if (y === "POST") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "POST") { return Data$dOrdering.GT; }
+    if (x === "PUT") {
+      if (y === "PUT") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "PUT") { return Data$dOrdering.GT; }
+    if (x === "DELETE") {
+      if (y === "DELETE") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "DELETE") { return Data$dOrdering.GT; }
+    if (x === "TRACE") {
+      if (y === "TRACE") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "TRACE") { return Data$dOrdering.GT; }
+    if (x === "CONNECT") {
+      if (y === "CONNECT") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "CONNECT") { return Data$dOrdering.GT; }
+    if (x === "PROPFIND") {
+      if (y === "PROPFIND") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "PROPFIND") { return Data$dOrdering.GT; }
+    if (x === "PROPPATCH") {
+      if (y === "PROPPATCH") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "PROPPATCH") { return Data$dOrdering.GT; }
+    if (x === "MKCOL") {
+      if (y === "MKCOL") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "MKCOL") { return Data$dOrdering.GT; }
+    if (x === "COPY") {
+      if (y === "COPY") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "COPY") { return Data$dOrdering.GT; }
+    if (x === "MOVE") {
+      if (y === "MOVE") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "MOVE") { return Data$dOrdering.GT; }
+    if (x === "LOCK") {
+      if (y === "LOCK") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "LOCK") { return Data$dOrdering.GT; }
+    if (x === "UNLOCK") {
+      if (y === "UNLOCK") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "UNLOCK") { return Data$dOrdering.GT; }
+    if (x === "PATCH" && y === "PATCH") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqMethod
+};
+const eqCustomMethod = {eq: x => y => x === y};
+const ordCustomMethod = {compare: x => y => Data$dOrd.ordString.compare(x)(y), Eq0: () => eqCustomMethod};
+export {
+  $Method,
+  CONNECT,
+  COPY,
+  DELETE,
+  GET,
+  HEAD,
+  LOCK,
+  MKCOL,
+  MOVE,
+  OPTIONS,
+  PATCH,
+  POST,
+  PROPFIND,
+  PROPPATCH,
+  PUT,
+  TRACE,
+  UNLOCK,
+  eqCustomMethod,
+  eqMethod,
+  fromString,
+  ordCustomMethod,
+  ordMethod,
+  parse,
+  print,
+  showCustomMethod,
+  showMethod,
+  unCustomMethod
+};

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

@@ -0,0 +1,15 @@
+export const boolConj = function (b1) {
+  return function (b2) {
+    return b1 && b2;
+  };
+};
+
+export const boolDisj = function (b1) {
+  return function (b2) {
+    return b1 || b2;
+  };
+};
+
+export const boolNot = function (b) {
+  return !b;
+};