@explorable-viz/fluid 0.12.3 → 0.12.4

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

@@ -0,0 +1,104 @@
+import * as Record$dUnsafe from "../Record.Unsafe/index.js";
+import * as Type$dProxy from "../Type.Proxy/index.js";
+import {boolConj, boolDisj, boolNot} from "./foreign.js";
+const ttRecord = dict => dict.ttRecord;
+const tt = dict => dict.tt;
+const notRecord = dict => dict.notRecord;
+const not = dict => dict.not;
+const impliesRecord = dict => dict.impliesRecord;
+const implies = dict => dict.implies;
+const heytingAlgebraUnit = {ff: undefined, tt: undefined, implies: v => v1 => {}, conj: v => v1 => {}, disj: v => v1 => {}, not: v => {}};
+const heytingAlgebraRecordNil = {
+  conjRecord: v => v1 => v2 => ({}),
+  disjRecord: v => v1 => v2 => ({}),
+  ffRecord: v => v1 => ({}),
+  impliesRecord: v => v1 => v2 => ({}),
+  notRecord: v => v1 => ({}),
+  ttRecord: v => v1 => ({})
+};
+const heytingAlgebraProxy = {
+  conj: v => v1 => Type$dProxy.Proxy,
+  disj: v => v1 => Type$dProxy.Proxy,
+  implies: v => v1 => Type$dProxy.Proxy,
+  ff: Type$dProxy.Proxy,
+  not: v => Type$dProxy.Proxy,
+  tt: Type$dProxy.Proxy
+};
+const ffRecord = dict => dict.ffRecord;
+const ff = dict => dict.ff;
+const disjRecord = dict => dict.disjRecord;
+const disj = dict => dict.disj;
+const heytingAlgebraBoolean = {ff: false, tt: true, implies: a => b => heytingAlgebraBoolean.disj(heytingAlgebraBoolean.not(a))(b), conj: boolConj, disj: boolDisj, not: boolNot};
+const conjRecord = dict => dict.conjRecord;
+const heytingAlgebraRecord = () => dictHeytingAlgebraRecord => (
+  {
+    ff: dictHeytingAlgebraRecord.ffRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    tt: dictHeytingAlgebraRecord.ttRecord(Type$dProxy.Proxy)(Type$dProxy.Proxy),
+    conj: dictHeytingAlgebraRecord.conjRecord(Type$dProxy.Proxy),
+    disj: dictHeytingAlgebraRecord.disjRecord(Type$dProxy.Proxy),
+    implies: dictHeytingAlgebraRecord.impliesRecord(Type$dProxy.Proxy),
+    not: dictHeytingAlgebraRecord.notRecord(Type$dProxy.Proxy)
+  }
+);
+const conj = dict => dict.conj;
+const heytingAlgebraFunction = dictHeytingAlgebra => {
+  const ff1 = dictHeytingAlgebra.ff;
+  const tt1 = dictHeytingAlgebra.tt;
+  return {
+    ff: v => ff1,
+    tt: v => tt1,
+    implies: f => g => a => dictHeytingAlgebra.implies(f(a))(g(a)),
+    conj: f => g => a => dictHeytingAlgebra.conj(f(a))(g(a)),
+    disj: f => g => a => dictHeytingAlgebra.disj(f(a))(g(a)),
+    not: f => a => dictHeytingAlgebra.not(f(a))
+  };
+};
+const heytingAlgebraRecordCons = dictIsSymbol => () => dictHeytingAlgebraRecord => dictHeytingAlgebra => {
+  const ff1 = dictHeytingAlgebra.ff;
+  const tt1 = dictHeytingAlgebra.tt;
+  return {
+    conjRecord: v => ra => rb => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      const $$get = Record$dUnsafe.unsafeGet(key);
+      return Record$dUnsafe.unsafeSet(key)(dictHeytingAlgebra.conj($$get(ra))($$get(rb)))(dictHeytingAlgebraRecord.conjRecord(Type$dProxy.Proxy)(ra)(rb));
+    },
+    disjRecord: v => ra => rb => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      const $$get = Record$dUnsafe.unsafeGet(key);
+      return Record$dUnsafe.unsafeSet(key)(dictHeytingAlgebra.disj($$get(ra))($$get(rb)))(dictHeytingAlgebraRecord.disjRecord(Type$dProxy.Proxy)(ra)(rb));
+    },
+    impliesRecord: v => ra => rb => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      const $$get = Record$dUnsafe.unsafeGet(key);
+      return Record$dUnsafe.unsafeSet(key)(dictHeytingAlgebra.implies($$get(ra))($$get(rb)))(dictHeytingAlgebraRecord.impliesRecord(Type$dProxy.Proxy)(ra)(rb));
+    },
+    ffRecord: v => row => Record$dUnsafe.unsafeSet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy))(ff1)(dictHeytingAlgebraRecord.ffRecord(Type$dProxy.Proxy)(row)),
+    notRecord: v => row => {
+      const key = dictIsSymbol.reflectSymbol(Type$dProxy.Proxy);
+      return Record$dUnsafe.unsafeSet(key)(dictHeytingAlgebra.not(Record$dUnsafe.unsafeGet(key)(row)))(dictHeytingAlgebraRecord.notRecord(Type$dProxy.Proxy)(row));
+    },
+    ttRecord: v => row => Record$dUnsafe.unsafeSet(dictIsSymbol.reflectSymbol(Type$dProxy.Proxy))(tt1)(dictHeytingAlgebraRecord.ttRecord(Type$dProxy.Proxy)(row))
+  };
+};
+export {
+  conj,
+  conjRecord,
+  disj,
+  disjRecord,
+  ff,
+  ffRecord,
+  heytingAlgebraBoolean,
+  heytingAlgebraFunction,
+  heytingAlgebraProxy,
+  heytingAlgebraRecord,
+  heytingAlgebraRecordCons,
+  heytingAlgebraRecordNil,
+  heytingAlgebraUnit,
+  implies,
+  impliesRecord,
+  not,
+  notRecord,
+  tt,
+  ttRecord
+};
+export * from "./foreign.js";

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

@@ -0,0 +1,76 @@
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+const genericTT$p = dict => dict["genericTT'"];
+const genericTT = dictGeneric => dictGenericHeytingAlgebra => dictGeneric.to(dictGenericHeytingAlgebra["genericTT'"]);
+const genericNot$p = dict => dict["genericNot'"];
+const genericNot = dictGeneric => dictGenericHeytingAlgebra => x => dictGeneric.to(dictGenericHeytingAlgebra["genericNot'"](dictGeneric.from(x)));
+const genericImplies$p = dict => dict["genericImplies'"];
+const genericImplies = dictGeneric => dictGenericHeytingAlgebra => x => y => dictGeneric.to(dictGenericHeytingAlgebra["genericImplies'"](dictGeneric.from(x))(dictGeneric.from(y)));
+const genericHeytingAlgebraNoArguments = {
+  "genericFF'": Data$dGeneric$dRep.NoArguments,
+  "genericTT'": Data$dGeneric$dRep.NoArguments,
+  "genericImplies'": v => v1 => Data$dGeneric$dRep.NoArguments,
+  "genericConj'": v => v1 => Data$dGeneric$dRep.NoArguments,
+  "genericDisj'": v => v1 => Data$dGeneric$dRep.NoArguments,
+  "genericNot'": v => Data$dGeneric$dRep.NoArguments
+};
+const genericHeytingAlgebraArgument = dictHeytingAlgebra => (
+  {
+    "genericFF'": dictHeytingAlgebra.ff,
+    "genericTT'": dictHeytingAlgebra.tt,
+    "genericImplies'": v => v1 => dictHeytingAlgebra.implies(v)(v1),
+    "genericConj'": v => v1 => dictHeytingAlgebra.conj(v)(v1),
+    "genericDisj'": v => v1 => dictHeytingAlgebra.disj(v)(v1),
+    "genericNot'": v => dictHeytingAlgebra.not(v)
+  }
+);
+const genericFF$p = dict => dict["genericFF'"];
+const genericFF = dictGeneric => dictGenericHeytingAlgebra => dictGeneric.to(dictGenericHeytingAlgebra["genericFF'"]);
+const genericDisj$p = dict => dict["genericDisj'"];
+const genericDisj = dictGeneric => dictGenericHeytingAlgebra => x => y => dictGeneric.to(dictGenericHeytingAlgebra["genericDisj'"](dictGeneric.from(x))(dictGeneric.from(y)));
+const genericConj$p = dict => dict["genericConj'"];
+const genericHeytingAlgebraConstructor = dictGenericHeytingAlgebra => (
+  {
+    "genericFF'": dictGenericHeytingAlgebra["genericFF'"],
+    "genericTT'": dictGenericHeytingAlgebra["genericTT'"],
+    "genericImplies'": v => v1 => dictGenericHeytingAlgebra["genericImplies'"](v)(v1),
+    "genericConj'": v => v1 => dictGenericHeytingAlgebra["genericConj'"](v)(v1),
+    "genericDisj'": v => v1 => dictGenericHeytingAlgebra["genericDisj'"](v)(v1),
+    "genericNot'": v => dictGenericHeytingAlgebra["genericNot'"](v)
+  }
+);
+const genericHeytingAlgebraProduct = dictGenericHeytingAlgebra => {
+  const genericFF$p1 = dictGenericHeytingAlgebra["genericFF'"];
+  const genericTT$p1 = dictGenericHeytingAlgebra["genericTT'"];
+  return dictGenericHeytingAlgebra1 => (
+    {
+      "genericFF'": Data$dGeneric$dRep.$Product(genericFF$p1, dictGenericHeytingAlgebra1["genericFF'"]),
+      "genericTT'": Data$dGeneric$dRep.$Product(genericTT$p1, dictGenericHeytingAlgebra1["genericTT'"]),
+      "genericImplies'": v => v1 => Data$dGeneric$dRep.$Product(
+        dictGenericHeytingAlgebra["genericImplies'"](v._1)(v1._1),
+        dictGenericHeytingAlgebra1["genericImplies'"](v._2)(v1._2)
+      ),
+      "genericConj'": v => v1 => Data$dGeneric$dRep.$Product(dictGenericHeytingAlgebra["genericConj'"](v._1)(v1._1), dictGenericHeytingAlgebra1["genericConj'"](v._2)(v1._2)),
+      "genericDisj'": v => v1 => Data$dGeneric$dRep.$Product(dictGenericHeytingAlgebra["genericDisj'"](v._1)(v1._1), dictGenericHeytingAlgebra1["genericDisj'"](v._2)(v1._2)),
+      "genericNot'": v => Data$dGeneric$dRep.$Product(dictGenericHeytingAlgebra["genericNot'"](v._1), dictGenericHeytingAlgebra1["genericNot'"](v._2))
+    }
+  );
+};
+const genericConj = dictGeneric => dictGenericHeytingAlgebra => x => y => dictGeneric.to(dictGenericHeytingAlgebra["genericConj'"](dictGeneric.from(x))(dictGeneric.from(y)));
+export {
+  genericConj,
+  genericConj$p,
+  genericDisj,
+  genericDisj$p,
+  genericFF,
+  genericFF$p,
+  genericHeytingAlgebraArgument,
+  genericHeytingAlgebraConstructor,
+  genericHeytingAlgebraNoArguments,
+  genericHeytingAlgebraProduct,
+  genericImplies,
+  genericImplies$p,
+  genericNot,
+  genericNot$p,
+  genericTT,
+  genericTT$p
+};

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

@@ -0,0 +1,54 @@
+const Identity = x => x;
+const showIdentity = dictShow => ({show: v => "(Identity " + dictShow.show(v) + ")"});
+const semiringIdentity = dictSemiring => dictSemiring;
+const semigroupIdentity = dictSemigroup => dictSemigroup;
+const ringIdentity = dictRing => dictRing;
+const ordIdentity = dictOrd => dictOrd;
+const newtypeIdentity = {Coercible0: () => {}};
+const monoidIdentity = dictMonoid => dictMonoid;
+const lazyIdentity = dictLazy => dictLazy;
+const heytingAlgebraIdentity = dictHeytingAlgebra => dictHeytingAlgebra;
+const functorIdentity = {map: f => m => f(m)};
+const invariantIdentity = {imap: f => v => m => f(m)};
+const extendIdentity = {extend: f => m => f(m), Functor0: () => functorIdentity};
+const euclideanRingIdentity = dictEuclideanRing => dictEuclideanRing;
+const eqIdentity = dictEq => dictEq;
+const eq1Identity = {eq1: dictEq => dictEq.eq};
+const ord1Identity = {compare1: dictOrd => dictOrd.compare, Eq10: () => eq1Identity};
+const comonadIdentity = {extract: v => v, Extend0: () => extendIdentity};
+const commutativeRingIdentity = dictCommutativeRing => dictCommutativeRing;
+const boundedIdentity = dictBounded => dictBounded;
+const booleanAlgebraIdentity = dictBooleanAlgebra => dictBooleanAlgebra;
+const applyIdentity = {apply: v => v1 => v(v1), Functor0: () => functorIdentity};
+const bindIdentity = {bind: v => f => f(v), Apply0: () => applyIdentity};
+const applicativeIdentity = {pure: Identity, Apply0: () => applyIdentity};
+const monadIdentity = {Applicative0: () => applicativeIdentity, Bind1: () => bindIdentity};
+const altIdentity = {alt: x => v => x, Functor0: () => functorIdentity};
+export {
+  Identity,
+  altIdentity,
+  applicativeIdentity,
+  applyIdentity,
+  bindIdentity,
+  booleanAlgebraIdentity,
+  boundedIdentity,
+  commutativeRingIdentity,
+  comonadIdentity,
+  eq1Identity,
+  eqIdentity,
+  euclideanRingIdentity,
+  extendIdentity,
+  functorIdentity,
+  heytingAlgebraIdentity,
+  invariantIdentity,
+  lazyIdentity,
+  monadIdentity,
+  monoidIdentity,
+  newtypeIdentity,
+  ord1Identity,
+  ordIdentity,
+  ringIdentity,
+  semigroupIdentity,
+  semiringIdentity,
+  showIdentity
+};

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

@@ -0,0 +1,65 @@
+export const fromNumberImpl = function (just) {
+  return function (nothing) {
+    return function (n) {
+      /* jshint bitwise: false */
+      return (n | 0) === n ? just(n) : nothing;
+    };
+  };
+};
+
+export const toNumber = function (n) {
+  return n;
+};
+
+export const fromStringAsImpl = function (just) {
+  return function (nothing) {
+    return function (radix) {
+      var digits;
+      if (radix < 11) {
+        digits = "[0-" + (radix - 1).toString() + "]";
+      } else if (radix === 11) {
+        digits = "[0-9a]";
+      } else {
+        digits = "[0-9a-" + String.fromCharCode(86 + radix) + "]";
+      }
+      var pattern = new RegExp("^[\\+\\-]?" + digits + "+$", "i");
+
+      return function (s) {
+        /* jshint bitwise: false */
+        if (pattern.test(s)) {
+          var i = parseInt(s, radix);
+          return (i | 0) === i ? just(i) : nothing;
+        } else {
+          return nothing;
+        }
+      };
+    };
+  };
+};
+
+export const toStringAs = function (radix) {
+  return function (i) {
+    return i.toString(radix);
+  };
+};
+
+
+export const quot = function (x) {
+  return function (y) {
+    /* jshint bitwise: false */
+    return x / y | 0;
+  };
+};
+
+export const rem = function (x) {
+  return function (y) {
+    return x % y;
+  };
+};
+
+export const pow = function (x) {
+  return function (y) {
+    /* jshint bitwise: false */
+    return Math.pow(x,y) | 0;
+  };
+};

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

@@ -0,0 +1,122 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dNumber from "../Data.Number/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import {fromNumberImpl, fromStringAsImpl, pow, quot, rem, toNumber, toStringAs} from "./foreign.js";
+const $Parity = tag => tag;
+const Even = /* #__PURE__ */ $Parity("Even");
+const Odd = /* #__PURE__ */ $Parity("Odd");
+const showParity = {
+  show: v => {
+    if (v === "Even") { return "Even"; }
+    if (v === "Odd") { return "Odd"; }
+    $runtime.fail();
+  }
+};
+const radix = n => {
+  if (n >= 2 && n <= 36) { return Data$dMaybe.$Maybe("Just", n); }
+  return Data$dMaybe.Nothing;
+};
+const odd = x => (x & 1) !== 0;
+const octal = 8;
+const hexadecimal = 16;
+const fromStringAs = /* #__PURE__ */ fromStringAsImpl(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const fromString = /* #__PURE__ */ fromStringAs(10);
+const fromNumber = /* #__PURE__ */ fromNumberImpl(Data$dMaybe.Just)(Data$dMaybe.Nothing);
+const unsafeClamp = x => {
+  if (!Data$dNumber.isFinite(x)) { return 0; }
+  if (x >= toNumber(2147483647)) { return 2147483647; }
+  if (x <= toNumber(-2147483648)) { return -2147483648; }
+  const $0 = fromNumber(x);
+  if ($0.tag === "Nothing") { return 0; }
+  if ($0.tag === "Just") { return $0._1; }
+  $runtime.fail();
+};
+const round = x => unsafeClamp(Data$dNumber.round(x));
+const trunc = x => unsafeClamp(Data$dNumber.trunc(x));
+const floor = x => unsafeClamp(Data$dNumber.floor(x));
+const even = x => (x & 1) === 0;
+const parity = n => {
+  if ((n & 1) === 0) { return Even; }
+  return Odd;
+};
+const eqParity = {
+  eq: x => y => {
+    if (x === "Even") { return y === "Even"; }
+    return x === "Odd" && y === "Odd";
+  }
+};
+const ordParity = {
+  compare: x => y => {
+    if (x === "Even") {
+      if (y === "Even") { return Data$dOrdering.EQ; }
+      return Data$dOrdering.LT;
+    }
+    if (y === "Even") { return Data$dOrdering.GT; }
+    if (x === "Odd" && y === "Odd") { return Data$dOrdering.EQ; }
+    $runtime.fail();
+  },
+  Eq0: () => eqParity
+};
+const semiringParity = {
+  zero: Even,
+  add: x => y => {
+    if (x === "Even" ? y === "Even" : x === "Odd" && y === "Odd") { return Even; }
+    return Odd;
+  },
+  one: Odd,
+  mul: v => v1 => {
+    if (v === "Odd" && v1 === "Odd") { return Odd; }
+    return Even;
+  }
+};
+const ringParity = /* #__PURE__ */ (() => ({sub: semiringParity.add, Semiring0: () => semiringParity}))();
+const divisionRingParity = {recip: x => x, Ring0: () => ringParity};
+const decimal = 10;
+const commutativeRingParity = {Ring0: () => ringParity};
+const euclideanRingParity = {
+  degree: v => {
+    if (v === "Even") { return 0; }
+    if (v === "Odd") { return 1; }
+    $runtime.fail();
+  },
+  div: x => v => x,
+  mod: v => v1 => Even,
+  CommutativeRing0: () => commutativeRingParity
+};
+const ceil = x => unsafeClamp(Data$dNumber.ceil(x));
+const boundedParity = {bottom: Even, top: Odd, Ord0: () => ordParity};
+const binary = 2;
+const base36 = 36;
+export {
+  $Parity,
+  Even,
+  Odd,
+  base36,
+  binary,
+  boundedParity,
+  ceil,
+  commutativeRingParity,
+  decimal,
+  divisionRingParity,
+  eqParity,
+  euclideanRingParity,
+  even,
+  floor,
+  fromNumber,
+  fromString,
+  fromStringAs,
+  hexadecimal,
+  octal,
+  odd,
+  ordParity,
+  parity,
+  radix,
+  ringParity,
+  round,
+  semiringParity,
+  showParity,
+  trunc,
+  unsafeClamp
+};
+export * from "./foreign.js";

package/output-es/Data.Int.Bits/foreign.js

@@ -0,0 +1,48 @@
+// module Data.Int.Bits
+
+export const and = function (n1) {
+  return function (n2) {
+    /* jshint bitwise: false */
+    return n1 & n2;
+  };
+};
+
+export const or = function (n1) {
+  return function (n2) {
+    /* jshint bitwise: false */
+    return n1 | n2;
+  };
+};
+
+export const xor = function (n1) {
+  return function (n2) {
+    /* jshint bitwise: false */
+    return n1 ^ n2;
+  };
+};
+
+export const shl = function (n1) {
+  return function (n2) {
+    /* jshint bitwise: false */
+    return n1 << n2;
+  };
+};
+
+export const shr = function (n1) {
+  return function (n2) {
+    /* jshint bitwise: false */
+    return n1 >> n2;
+  };
+};
+
+export const zshr = function (n1) {
+  return function (n2) {
+    /* jshint bitwise: false */
+    return n1 >>> n2;
+  };
+};
+
+export const complement = function (n) {
+  /* jshint bitwise: false */
+  return ~n;
+};

package/output-es/Data.Int.Bits/index.js

@@ -0,0 +1,4 @@
+// | This module defines bitwise operations for the `Int` type.
+import {and, complement, or, shl, shr, xor, zshr} from "./foreign.js";
+export {};
+export * from "./foreign.js";