@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,161 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {ordArrayImpl, ordBooleanImpl, ordCharImpl, ordIntImpl, ordNumberImpl, ordStringImpl} from "./foreign.js";
+const ordVoid = {compare: v => v1 => Data$dOrdering.EQ, Eq0: () => Data$dEq.eqVoid};
+const ordUnit = {compare: v => v1 => Data$dOrdering.EQ, Eq0: () => Data$dEq.eqUnit};
+const ordString = {compare: /* #__PURE__ */ ordStringImpl(Data$dOrdering.LT)(Data$dOrdering.EQ)(Data$dOrdering.GT), Eq0: () => Data$dEq.eqString};
+const ordRecordNil = {compareRecord: v => v1 => v2 => Data$dOrdering.EQ, EqRecord0: () => Data$dEq.eqRowNil};
+const ordProxy = {compare: v => v1 => Data$dOrdering.EQ, Eq0: () => Data$dEq.eqProxy};
+const ordOrdering = {
+  compare: v => v1 => {
+    if (v === "LT") {
+      if (v1 === "LT") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (v === "EQ") {
+      if (v1 === "EQ") { return Data$dOrdering.EQ; }
+      if (v1 === "LT") { return Data$dOrdering.GT; }
+      if (v1 === "GT") { return Data$dOrdering.LT; }
+      $runtime.fail();
+    }
+    if (v === "GT") {
+      if (v1 === "GT") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.GT;
+    }
+    $runtime.fail();
+  },
+  Eq0: () => Data$dOrdering.eqOrdering
+};
+const ordNumber = {compare: /* #__PURE__ */ ordNumberImpl(Data$dOrdering.LT)(Data$dOrdering.EQ)(Data$dOrdering.GT), Eq0: () => Data$dEq.eqNumber};
+const ordInt = {compare: /* #__PURE__ */ ordIntImpl(Data$dOrdering.LT)(Data$dOrdering.EQ)(Data$dOrdering.GT), Eq0: () => Data$dEq.eqInt};
+const ordChar = {compare: /* #__PURE__ */ ordCharImpl(Data$dOrdering.LT)(Data$dOrdering.EQ)(Data$dOrdering.GT), Eq0: () => Data$dEq.eqChar};
+const ordBoolean = {compare: /* #__PURE__ */ ordBooleanImpl(Data$dOrdering.LT)(Data$dOrdering.EQ)(Data$dOrdering.GT), Eq0: () => Data$dEq.eqBoolean};
+const compareRecord = dict => dict.compareRecord;
+const ordRecord = () => dictOrdRecord => {
+  const eqRec1 = {eq: dictOrdRecord.EqRecord0().eqRecord(Type$dProxy.Proxy)};
+  return {compare: dictOrdRecord.compareRecord(Type$dProxy.Proxy), Eq0: () => eqRec1};
+};
+const compare1 = dict => dict.compare1;
+const compare = dict => dict.compare;
+const comparing = dictOrd => f => x => y => dictOrd.compare(f(x))(f(y));
+const greaterThan = dictOrd => a1 => a2 => dictOrd.compare(a1)(a2) === "GT";
+const greaterThanOrEq = dictOrd => a1 => a2 => dictOrd.compare(a1)(a2) !== "LT";
+const lessThan = dictOrd => a1 => a2 => dictOrd.compare(a1)(a2) === "LT";
+const signum = dictOrd => dictRing => {
+  const Semiring0 = dictRing.Semiring0();
+  const zero = Semiring0.zero;
+  const zero$1 = dictRing.Semiring0().zero;
+  const one = Semiring0.one;
+  return x => {
+    if (dictOrd.compare(x)(zero) === "LT") { return dictRing.sub(zero$1)(one); }
+    if (dictOrd.compare(x)(zero) === "GT") { return one; }
+    return x;
+  };
+};
+const lessThanOrEq = dictOrd => a1 => a2 => dictOrd.compare(a1)(a2) !== "GT";
+const max = dictOrd => x => y => {
+  const v = dictOrd.compare(x)(y);
+  if (v === "LT") { return y; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return x; }
+  $runtime.fail();
+};
+const min = dictOrd => x => y => {
+  const v = dictOrd.compare(x)(y);
+  if (v === "LT") { return x; }
+  if (v === "EQ") { return x; }
+  if (v === "GT") { return y; }
+  $runtime.fail();
+};
+const ordArray = dictOrd => {
+  const eqArray = {eq: Data$dEq.eqArrayImpl(dictOrd.Eq0().eq)};
+  return {
+    compare: xs => ys => ordInt.compare(0)(ordArrayImpl(x => y => {
+      const v = dictOrd.compare(x)(y);
+      if (v === "EQ") { return 0; }
+      if (v === "LT") { return 1; }
+      if (v === "GT") { return -1; }
+      $runtime.fail();
+    })(xs)(ys)),
+    Eq0: () => eqArray
+  };
+};
+const ord1Array = {compare1: dictOrd => ordArray(dictOrd).compare, Eq10: () => Data$dEq.eq1Array};
+const ordRecordCons = dictOrdRecord => {
+  const eqRowCons = Data$dEq.eqRowCons(dictOrdRecord.EqRecord0())();
+  return () => dictIsSymbol => {
+    const eqRowCons1 = eqRowCons(dictIsSymbol);
+    return dictOrd => {
+      const eqRowCons2 = eqRowCons1(dictOrd.Eq0());
+      return {
+        compareRecord: v => ra => rb => {
+          const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+          const left = dictOrd.compare(Record$dUnsafe.unsafeGet(key)(ra))(Record$dUnsafe.unsafeGet(key)(rb));
+          if (left === "LT" || left === "GT" || left !== "EQ") { return left; }
+          return dictOrdRecord.compareRecord(Type$dProxy.Proxy)(ra)(rb);
+        },
+        EqRecord0: () => eqRowCons2
+      };
+    };
+  };
+};
+const clamp = dictOrd => low => hi => x => {
+  const v = dictOrd.compare(low)(x);
+  const $0 = (() => {
+    if (v === "LT") { return x; }
+    if (v === "EQ") { return low; }
+    if (v === "GT") { return low; }
+    $runtime.fail();
+  })();
+  const v$1 = dictOrd.compare(hi)($0);
+  if (v$1 === "LT") { return hi; }
+  if (v$1 === "EQ") { return hi; }
+  if (v$1 === "GT") { return $0; }
+  $runtime.fail();
+};
+const between = dictOrd => low => hi => x => {
+  if (dictOrd.compare(x)(low) === "LT") { return false; }
+  return dictOrd.compare(x)(hi) !== "GT";
+};
+const abs = dictOrd => dictRing => {
+  const zero = dictRing.Semiring0().zero;
+  const zero$1 = dictRing.Semiring0().zero;
+  return x => {
+    if (dictOrd.compare(x)(zero) !== "LT") { return x; }
+    return dictRing.sub(zero$1)(x);
+  };
+};
+export {
+  abs,
+  between,
+  clamp,
+  compare,
+  compare1,
+  compareRecord,
+  comparing,
+  greaterThan,
+  greaterThanOrEq,
+  lessThan,
+  lessThanOrEq,
+  max,
+  min,
+  ord1Array,
+  ordArray,
+  ordBoolean,
+  ordChar,
+  ordInt,
+  ordNumber,
+  ordOrdering,
+  ordProxy,
+  ordRecord,
+  ordRecordCons,
+  ordRecordNil,
+  ordString,
+  ordUnit,
+  ordVoid,
+  signum
+};
+export * from "./foreign.js";

package/output-es/Data.Ord.Down/index.js

@@ -0,0 +1,35 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const Down = x => x;
+const showDown = dictShow => ({show: v => "(Down " + dictShow.show(v) + ")"});
+const newtypeDown = {Coercible0: () => {}};
+const eqDown = dictEq => dictEq;
+const ordDown = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  return {
+    compare: v => v1 => {
+      const $1 = dictOrd.compare(v)(v1);
+      if ($1 === "GT") { return Data$dOrdering.LT; }
+      if ($1 === "EQ") { return Data$dOrdering.EQ; }
+      if ($1 === "LT") { return Data$dOrdering.GT; }
+      $runtime.fail();
+    },
+    Eq0: () => $0
+  };
+};
+const boundedDown = dictBounded => {
+  const $0 = dictBounded.Ord0();
+  const $1 = $0.Eq0();
+  const ordDown1 = {
+    compare: v => v1 => {
+      const $2 = $0.compare(v)(v1);
+      if ($2 === "GT") { return Data$dOrdering.LT; }
+      if ($2 === "EQ") { return Data$dOrdering.EQ; }
+      if ($2 === "LT") { return Data$dOrdering.GT; }
+      $runtime.fail();
+    },
+    Eq0: () => $1
+  };
+  return {top: dictBounded.bottom, bottom: dictBounded.top, Ord0: () => ordDown1};
+};
+export {Down, boundedDown, eqDown, newtypeDown, ordDown, showDown};

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

@@ -0,0 +1,34 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const genericOrdNoConstructors = {"genericCompare'": v => v1 => Data$dOrdering.EQ};
+const genericOrdNoArguments = {"genericCompare'": v => v1 => Data$dOrdering.EQ};
+const genericOrdArgument = dictOrd => ({"genericCompare'": v => v1 => dictOrd.compare(v)(v1)});
+const genericCompare$p = dict => dict["genericCompare'"];
+const genericOrdConstructor = dictGenericOrd => ({"genericCompare'": v => v1 => dictGenericOrd["genericCompare'"](v)(v1)});
+const genericOrdProduct = dictGenericOrd => dictGenericOrd1 => (
+  {
+    "genericCompare'": v => v1 => {
+      const v2 = dictGenericOrd["genericCompare'"](v._1)(v1._1);
+      if (v2 === "EQ") { return dictGenericOrd1["genericCompare'"](v._2)(v1._2); }
+      return v2;
+    }
+  }
+);
+const genericOrdSum = dictGenericOrd => dictGenericOrd1 => (
+  {
+    "genericCompare'": v => v1 => {
+      if (v.tag === "Inl") {
+        if (v1.tag === "Inl") { return dictGenericOrd["genericCompare'"](v._1)(v1._1); }
+        if (v1.tag === "Inr") { return Data$dOrdering.LT; }
+        $runtime.fail();
+      }
+      if (v.tag === "Inr") {
+        if (v1.tag === "Inr") { return dictGenericOrd1["genericCompare'"](v._1)(v1._1); }
+        if (v1.tag === "Inl") { return Data$dOrdering.GT; }
+      }
+      $runtime.fail();
+    }
+  }
+);
+const genericCompare = dictGeneric => dictGenericOrd => x => y => dictGenericOrd["genericCompare'"](dictGeneric.from(x))(dictGeneric.from(y));
+export {genericCompare, genericCompare$p, genericOrdArgument, genericOrdConstructor, genericOrdNoArguments, genericOrdNoConstructors, genericOrdProduct, genericOrdSum};

package/output-es/Data.Ord.Max/index.js

@@ -0,0 +1,34 @@
+import * as $runtime from "../runtime.js";
+const Max = x => x;
+const showMax = dictShow => ({show: v => "(Max " + dictShow.show(v) + ")"});
+const semigroupMax = dictOrd => (
+  {
+    append: v => v1 => {
+      const v$1 = dictOrd.compare(v)(v1);
+      if (v$1 === "LT") { return v1; }
+      if (v$1 === "EQ") { return v; }
+      if (v$1 === "GT") { return v; }
+      $runtime.fail();
+    }
+  }
+);
+const newtypeMax = {Coercible0: () => {}};
+const monoidMax = dictBounded => {
+  const $0 = dictBounded.Ord0();
+  const semigroupMax1 = {
+    append: v => v1 => {
+      const v$1 = $0.compare(v)(v1);
+      if (v$1 === "LT") { return v1; }
+      if (v$1 === "EQ") { return v; }
+      if (v$1 === "GT") { return v; }
+      $runtime.fail();
+    }
+  };
+  return {mempty: dictBounded.bottom, Semigroup0: () => semigroupMax1};
+};
+const eqMax = dictEq => dictEq;
+const ordMax = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  return {compare: v => v1 => dictOrd.compare(v)(v1), Eq0: () => $0};
+};
+export {Max, eqMax, monoidMax, newtypeMax, ordMax, semigroupMax, showMax};

package/output-es/Data.Ord.Min/index.js

@@ -0,0 +1,34 @@
+import * as $runtime from "../runtime.js";
+const Min = x => x;
+const showMin = dictShow => ({show: v => "(Min " + dictShow.show(v) + ")"});
+const semigroupMin = dictOrd => (
+  {
+    append: v => v1 => {
+      const v$1 = dictOrd.compare(v)(v1);
+      if (v$1 === "LT") { return v; }
+      if (v$1 === "EQ") { return v; }
+      if (v$1 === "GT") { return v1; }
+      $runtime.fail();
+    }
+  }
+);
+const newtypeMin = {Coercible0: () => {}};
+const monoidMin = dictBounded => {
+  const $0 = dictBounded.Ord0();
+  const semigroupMin1 = {
+    append: v => v1 => {
+      const v$1 = $0.compare(v)(v1);
+      if (v$1 === "LT") { return v; }
+      if (v$1 === "EQ") { return v; }
+      if (v$1 === "GT") { return v1; }
+      $runtime.fail();
+    }
+  };
+  return {mempty: dictBounded.top, Semigroup0: () => semigroupMin1};
+};
+const eqMin = dictEq => dictEq;
+const ordMin = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  return {compare: v => v1 => dictOrd.compare(v)(v1), Eq0: () => $0};
+};
+export {Min, eqMin, monoidMin, newtypeMin, ordMin, semigroupMin, showMin};

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

@@ -0,0 +1,35 @@
+import * as $runtime from "../runtime.js";
+const $Ordering = tag => tag;
+const LT = /* #__PURE__ */ $Ordering("LT");
+const GT = /* #__PURE__ */ $Ordering("GT");
+const EQ = /* #__PURE__ */ $Ordering("EQ");
+const showOrdering = {
+  show: v => {
+    if (v === "LT") { return "LT"; }
+    if (v === "GT") { return "GT"; }
+    if (v === "EQ") { return "EQ"; }
+    $runtime.fail();
+  }
+};
+const semigroupOrdering = {
+  append: v => v1 => {
+    if (v === "LT") { return LT; }
+    if (v === "GT") { return GT; }
+    if (v === "EQ") { return v1; }
+    $runtime.fail();
+  }
+};
+const invert = v => {
+  if (v === "GT") { return LT; }
+  if (v === "EQ") { return EQ; }
+  if (v === "LT") { return GT; }
+  $runtime.fail();
+};
+const eqOrdering = {
+  eq: v => v1 => {
+    if (v === "LT") { return v1 === "LT"; }
+    if (v === "GT") { return v1 === "GT"; }
+    return v === "EQ" && v1 === "EQ";
+  }
+};
+export {$Ordering, EQ, GT, LT, eqOrdering, invert, semigroupOrdering, showOrdering};

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

@@ -0,0 +1,19 @@
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+const Uid = x => x;
+const Pid = x => x;
+const Gid = x => x;
+const showUid = {show: v => "(Uid " + Data$dShow.showIntImpl(v) + ")"};
+const showPid = {show: v => "(Pid " + Data$dShow.showIntImpl(v) + ")"};
+const showGid = {show: v => "(Gid " + Data$dShow.showIntImpl(v) + ")"};
+const ordUid = Data$dOrd.ordInt;
+const ordPid = Data$dOrd.ordInt;
+const ordGid = Data$dOrd.ordInt;
+const newtypeUid = {Coercible0: () => {}};
+const newtypePid = {Coercible0: () => {}};
+const newtypeGid = {Coercible0: () => {}};
+const eqUid = Data$dEq.eqInt;
+const eqPid = Data$dEq.eqInt;
+const eqGid = Data$dEq.eqInt;
+export {Gid, Pid, Uid, eqGid, eqPid, eqUid, newtypeGid, newtypePid, newtypeUid, ordGid, ordPid, ordUid, showGid, showPid, showUid};