@hviana/sema 0.1.5 → 0.1.7

package/dist/src/alu/src/value.js

@@ -46,8 +46,8 @@ export const int = (n) => ({ domain: "int", n });
 export const real = (x) => ({ domain: "real", x });
 /** A symbolic value: an opaque byte span of any modality (see module note). */
 export const symbol = (bytes) => ({
-  domain: "symbol",
-  bytes,
+    domain: "symbol",
+    bytes,
 });
 /** An n-dimensional value: an ordered list of element values (each any domain,
  *  including a nested nd).  See the module note on nd. */
@@ -57,11 +57,11 @@ export const tagOf = (v) => v.domain;
 /** Whether a value is a numeric SCALAR (bit, int, or real) — an nd is not, even
  *  if every element is numeric (it is a container; reduce it to a scalar). */
 export function isNumeric(v) {
-  return v.domain === "bit" || v.domain === "int" || v.domain === "real";
+    return v.domain === "bit" || v.domain === "int" || v.domain === "real";
 }
 /** Whether a value is the n-dimensional container. */
 export function isNd(v) {
-  return v.domain === "nd";
+    return v.domain === "nd";
 }
 /** Collect, into `out`, every SYMBOL byte span reachable inside a value — itself
  *  when it is a symbol, or each element recursively when it is an nd.  These are
@@ -69,13 +69,12 @@ export function isNd(v) {
  *  argument names) the host pre-resolves before a computation; numbers carry no
  *  meaning to resolve, so they are skipped. */
 export function symbolSpans(v, out) {
-  if (v.domain === "symbol") {
-    out.push(v.bytes);
-  } else if (isNd(v)) {
-    for (const e of v.items) {
-      symbolSpans(e, out);
+    if (v.domain === "symbol")
+        out.push(v.bytes);
+    else if (isNd(v)) {
+        for (const e of v.items)
+            symbolSpans(e, out);
     }
-  }
 }
 // ── coercions (the functor's object map between domains) ────────────────────
 /** A value as a JS number — bit→0|1, int→Number, real as-is.  Throws on a
@@ -83,108 +82,103 @@ export function symbolSpans(v, out) {
  *  caller (or the graph adapter's try/catch) should surface, never silently
  *  coerce to NaN. */
 export function asReal(v) {
-  switch (v.domain) {
-    case "bit":
-      return v.b;
-    case "int":
-      return Number(v.n);
-    case "real":
-      return v.x;
-    case "symbol":
-      throw new TypeError("asReal: a symbol value has no numeric reading");
-    case "nd":
-      // An nd has no scalar reading: a scalar primitive never sees one, because
-      // broadcast (operation.ts) lifts it element-wise first.  Reaching here
-      // means a structural op was mis-called on a list as if it were a scalar.
-      throw new TypeError("asReal: an nd value has no scalar numeric reading");
-  }
+    switch (v.domain) {
+        case "bit":
+            return v.b;
+        case "int":
+            return Number(v.n);
+        case "real":
+            return v.x;
+        case "symbol":
+            throw new TypeError("asReal: a symbol value has no numeric reading");
+        case "nd":
+            // An nd has no scalar reading: a scalar primitive never sees one, because
+            // broadcast (operation.ts) lifts it element-wise first.  Reaching here
+            // means a structural op was mis-called on a list as if it were a scalar.
+            throw new TypeError("asReal: an nd value has no scalar numeric reading");
+    }
 }
 /** A value as an exact bigint — real is truncated toward zero (a real that is
  *  not integral loses its fraction; callers wanting exactness keep it int). */
 export function asInt(v) {
-  switch (v.domain) {
-    case "bit":
-      return BigInt(v.b);
-    case "int":
-      return v.n;
-    case "real":
-      return BigInt(Math.trunc(v.x));
-    case "symbol":
-      throw new TypeError("asInt: a symbol value has no integer reading");
-    case "nd":
-      throw new TypeError("asInt: an nd value has no scalar integer reading");
-  }
+    switch (v.domain) {
+        case "bit":
+            return BigInt(v.b);
+        case "int":
+            return v.n;
+        case "real":
+            return BigInt(Math.trunc(v.x));
+        case "symbol":
+            throw new TypeError("asInt: a symbol value has no integer reading");
+        case "nd":
+            throw new TypeError("asInt: an nd value has no scalar integer reading");
+    }
 }
 /** A value as a logic bit — nonzero numbers read as 1, zero as 0.  Throws on a
  *  symbol (an opaque form is not a truth value). */
 export function asBit(v) {
-  switch (v.domain) {
-    case "bit":
-      return v.b;
-    case "int":
-      return v.n === 0n ? 0 : 1;
-    case "real":
-      return v.x === 0 ? 0 : 1;
-    case "symbol":
-      throw new TypeError("asBit: a symbol value is not a truth value");
-    case "nd":
-      throw new TypeError("asBit: an nd value is not a scalar truth value");
-  }
+    switch (v.domain) {
+        case "bit":
+            return v.b;
+        case "int":
+            return v.n === 0n ? 0 : 1;
+        case "real":
+            return v.x === 0 ? 0 : 1;
+        case "symbol":
+            throw new TypeError("asBit: a symbol value is not a truth value");
+        case "nd":
+            throw new TypeError("asBit: an nd value is not a scalar truth value");
+    }
 }
 /** Promote a value into a target numeric domain (bit ⊂ int ⊂ real).  Used when
  *  a mixed-domain expression must agree on one domain before a primitive runs —
  *  the rule is the natural lattice: any real operand pulls the whole expression
  *  to real, otherwise any int pulls it to int, otherwise bit. */
 export function coerce(v, domain) {
-  if (v.domain === domain) {
-    return v;
-  }
-  switch (domain) {
-    case "bit":
-      return bit(asBit(v));
-    case "int":
-      return int(asInt(v));
-    case "real":
-      return real(asReal(v));
-  }
+    if (v.domain === domain)
+        return v;
+    switch (domain) {
+        case "bit":
+            return bit(asBit(v));
+        case "int":
+            return int(asInt(v));
+        case "real":
+            return real(asReal(v));
+    }
 }
 /** The common numeric domain of a list of operands, by the bit ⊂ int ⊂ real
  *  lattice: real if any operand is real, else int if any is int, else bit.
  *  Throws if any operand is a symbol.  This is how a polymorphic arithmetic op
  *  decides whether to take the exact bigint path or the native-double path. */
 export function joinDomain(args) {
-  let d = "bit";
-  for (const a of args) {
-    if (a.domain === "symbol") {
-      throw new TypeError("joinDomain: cannot join a symbol value numerically");
-    }
-    if (a.domain === "nd") {
-      throw new TypeError("joinDomain: cannot join an nd value numerically");
-    }
-    if (a.domain === "real") {
-      return "real";
-    }
-    if (a.domain === "int" && d === "bit") {
-      d = "int";
+    let d = "bit";
+    for (const a of args) {
+        if (a.domain === "symbol") {
+            throw new TypeError("joinDomain: cannot join a symbol value numerically");
+        }
+        if (a.domain === "nd") {
+            throw new TypeError("joinDomain: cannot join an nd value numerically");
+        }
+        if (a.domain === "real")
+            return "real";
+        if (a.domain === "int" && d === "bit")
+            d = "int";
     }
-  }
-  return d;
+    return d;
 }
 const ASCII = {
-  decode: (b) => {
-    let s = "";
-    for (let i = 0; i < b.length; i++) {
-      s += String.fromCharCode(b[i]);
-    }
-    return s;
-  },
-  encode: (s) => {
-    const out = new Uint8Array(s.length);
-    for (let i = 0; i < s.length; i++) {
-      out[i] = s.charCodeAt(i) & 0xff;
-    }
-    return out;
-  },
+    decode: (b) => {
+        let s = "";
+        for (let i = 0; i < b.length; i++)
+            s += String.fromCharCode(b[i]);
+        return s;
+    },
+    encode: (s) => {
+        const out = new Uint8Array(s.length);
+        for (let i = 0; i < s.length; i++)
+            out[i] = s.charCodeAt(i) & 0xff;
+        return out;
+    },
 };
 /** A decimal numeral, sign, optional fraction, optional exponent — the syntax
  *  {@link parseScalar} accepts as a number.  Anything else is a symbol. */
@@ -192,38 +186,38 @@ const NUMERAL = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
 /** Concatenate byte arrays — used to build an nd literal's encoding without
  *  routing a (possibly non-ASCII, multimodal) symbol's bytes through a string. */
 function concatBytes(arrs) {
-  let len = 0;
-  for (const a of arrs) {
-    len += a.length;
-  }
-  const out = new Uint8Array(len);
-  let o = 0;
-  for (const a of arrs) {
-    out.set(a, o);
-    o += a.length;
-  }
-  return out;
+    let len = 0;
+    for (const a of arrs)
+        len += a.length;
+    const out = new Uint8Array(len);
+    let o = 0;
+    for (const a of arrs) {
+        out.set(a, o);
+        o += a.length;
+    }
+    return out;
 }
 /** Parse a SCALAR span: a clean integer numeral → exact int, a fractional/
  *  exponent numeral → real, anything else → a symbol carrying `bytes` verbatim.
  *  Strict, so it never hijacks a form that merely begins with a digit. */
 function parseScalar(bytes, s) {
-  if (s.length > 0 && NUMERAL.test(s)) {
-    if (/[.eE]/.test(s)) {
-      const x = Number(s);
-      if (Number.isFinite(x)) {
-        return real(x);
-      }
-    } else {
-      // A clean integer: strip a leading '+' that BigInt rejects.
-      try {
-        return int(BigInt(s[0] === "+" ? s.slice(1) : s));
-      } catch {
-        /* fall through to symbol */
-      }
+    if (s.length > 0 && NUMERAL.test(s)) {
+        if (/[.eE]/.test(s)) {
+            const x = Number(s);
+            if (Number.isFinite(x))
+                return real(x);
+        }
+        else {
+            // A clean integer: strip a leading '+' that BigInt rejects.
+            try {
+                return int(BigInt(s[0] === "+" ? s.slice(1) : s));
+            }
+            catch {
+                /* fall through to symbol */
+            }
+        }
     }
-  }
-  return symbol(bytes);
+    return symbol(bytes);
 }
 /** Parse a byte span into a SCALAR value: a clean integer numeral → exact int, a
  *  fractional/exponent numeral → real, anything else → a symbol carrying its
@@ -241,24 +235,21 @@ function parseScalar(bytes, s) {
  *  Numerals are ASCII by construction; for any other byte content the bytes are
  *  preserved opaquely, so a symbol of any modality round-trips untouched. */
 export function parseValue(bytes) {
-  return parseScalar(bytes, ASCII.decode(bytes));
+    return parseScalar(bytes, ASCII.decode(bytes));
 }
 /** Canonically format a real as a decimal string: round to `precision` places,
  *  then trim trailing zeros (and a bare trailing point), normalising -0 to 0.
  *  Determinism here is load-bearing — the search keys an output span by its
  *  bytes, so two derivations of the same number MUST spell it identically. */
 export function formatReal(x, precision) {
-  if (!Number.isFinite(x)) {
-    return String(x); // "Infinity" / "NaN" / "-Infinity"
-  }
-  let s = x.toFixed(precision);
-  if (s.indexOf(".") >= 0) {
-    s = s.replace(/\.?0+$/, "");
-  }
-  if (s === "-0" || s === "") {
-    s = "0";
-  }
-  return s;
+    if (!Number.isFinite(x))
+        return String(x); // "Infinity" / "NaN" / "-Infinity"
+    let s = x.toFixed(precision);
+    if (s.indexOf(".") >= 0)
+        s = s.replace(/\.?0+$/, "");
+    if (s === "-0" || s === "")
+        s = "0";
+    return s;
 }
 /** The default codec: integers as exact decimals, reals canonically formatted,
  *  bits as "0"/"1", symbols as their own bytes (verbatim, any modality), and an
@@ -273,38 +264,37 @@ export function formatReal(x, precision) {
  *  bracket literal decodes back to an opaque symbol.  Reading list STRUCTURE from
  *  bytes is layered one level up, in {@link "./alu.js".Alu.recogniseValue}. */
 export function decimalCodec(precision) {
-  const enc = (v) => {
-    switch (v.domain) {
-      case "bit":
-        return ASCII.encode(String(v.b));
-      case "int":
-        return ASCII.encode(v.n.toString());
-      case "real":
-        return ASCII.encode(formatReal(v.x, precision));
-      case "symbol":
-        return v.bytes;
-      case "nd": {
-        // [e0,e1,…] at the byte level, so a symbol element's arbitrary
-        // (possibly non-ASCII / multimodal) bytes pass through untouched.
-        const OPEN = ASCII.encode("[");
-        const CLOSE = ASCII.encode("]");
-        const COMMA = ASCII.encode(",");
-        const parts = [OPEN];
-        for (let i = 0; i < v.items.length; i++) {
-          if (i > 0) {
-            parts.push(COMMA);
-          }
-          parts.push(enc(v.items[i]));
+    const enc = (v) => {
+        switch (v.domain) {
+            case "bit":
+                return ASCII.encode(String(v.b));
+            case "int":
+                return ASCII.encode(v.n.toString());
+            case "real":
+                return ASCII.encode(formatReal(v.x, precision));
+            case "symbol":
+                return v.bytes;
+            case "nd": {
+                // [e0,e1,…] at the byte level, so a symbol element's arbitrary
+                // (possibly non-ASCII / multimodal) bytes pass through untouched.
+                const OPEN = ASCII.encode("[");
+                const CLOSE = ASCII.encode("]");
+                const COMMA = ASCII.encode(",");
+                const parts = [OPEN];
+                for (let i = 0; i < v.items.length; i++) {
+                    if (i > 0)
+                        parts.push(COMMA);
+                    parts.push(enc(v.items[i]));
+                }
+                parts.push(CLOSE);
+                return concatBytes(parts);
+            }
         }
-        parts.push(CLOSE);
-        return concatBytes(parts);
-      }
-    }
-  };
-  return {
-    encode: enc,
-    decode(bytes) {
-      return parseValue(bytes);
-    },
-  };
+    };
+    return {
+        encode: enc,
+        decode(bytes) {
+            return parseValue(bytes);
+        },
+    };
 }