functionalscript 0.33.0 → 0.34.0

package/fs/text/utf16/module.f.js

@@ -9,33 +9,11 @@ import { map, reduce, flatMap, empty, } from "../../types/list/module.f.js";
 import { concat } from "../../types/function/operator/module.f.js";
 import { contains } from "../../types/range/module.f.js";
 import { fn } from "../../types/function/module.f.js";
-import { decoder, errorMask } from "../code_point/module.f.js";
-/**
- * Ranges of code points for the lower (Low) and higher (High) parts of the BMP (Basic Multilingual Plane) plane.
- */
-const lowBmp = contains([0x0000, 0xd7ff]);
-const highBmp = contains([0xe000, 0xffff]);
-/**
- * Checks whether the code point is in the BMP range.
- * BMP is the main multi-plane Unicode plane that covers code points 0x0000 - 0xFFFF, except for the range of surrogates.
- */
-const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
-/**
- * Checks whether the 16-bit word (U16) is a surrogate of the high part.
- * Range: 0xD800 - 0xDBFF.
- */
-const isHighSurrogate = contains([0xd800, 0xdbff]);
-/**
- * Checks whether the 16-bit word (U16) is a substitute for the low part.
- * Range: 0xDC00 – 0xDFFF.
- */
-const isLowSurrogate = contains([0xdc00, 0xdfff]);
-/**
- * Checks whether the code point belongs to the additional (Supplementary) plane of Unicode.
- * Additional planes include code points from 0x010000 to 0x10FFFF.
- */
-const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
+import { decoder, errorMask, isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, } from "../code_point/module.f.js";
 /**
+ * The BMP / surrogate / supplementary-plane predicates used below live in
+ * `code_point`, the shared Unicode contract; see that module for their ranges.
+ *
  * Converts a Unicode code point to its corresponding UTF-16 representation.
  *
  * This function handles:

package/fs/text/utf8/module.f.d.ts

@@ -4,6 +4,7 @@
  * @module
  */
 import { type List, type Thunk } from '../../types/list/module.f.ts';
+import type { StateScan } from '../../types/function/operator/module.f.ts';
 import type { Array1, Array2, Array3 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 /**
@@ -35,6 +36,32 @@ export type Utf8State = null | Utf8NonEmptyState;
  * @returns A thunk that lazily produces a sequence of UTF-8 bytes.
  */
 export declare const fromCodePointList: (input: List<number>) => Thunk<U8>;
+/**
+ * Converts a non-empty UTF-8 decoding state to an error code.
+ *
+ * @param state - A non-empty UTF-8 decoding state.
+ * @returns An I32 error code derived from the invalid UTF-8 state.
+ */
+export declare const utf8StateToError: (state: Utf8NonEmptyState) => I32;
+/**
+ * Decodes a byte into a Unicode code point, using a given UTF-8 state.
+ *
+ * @param state - The current UTF-8 decoding state.
+ * @param byte - A single byte to decode.
+ * @returns A tuple containing:
+ *   - A list of decoded Unicode code points or error codes.
+ *   - The updated UTF-8 state.
+ */
+export declare const utf8ByteToCodePointOp: StateScan<number, Utf8State, readonly I32[]>;
+/**
+ * Handles the end-of-file (EOF) case for UTF-8 decoding.
+ *
+ * @param state - The current UTF-8 decoding state.
+ * @returns A tuple containing:
+ *   - A list of decoded Unicode code points or error codes.
+ *   - The reset UTF-8 state (`null`).
+ */
+export declare const utf8EofToCodePointOp: (state: Utf8State) => readonly [List<I32>, Utf8State];
 /**
  * Converts a list of UTF-8 bytes into a list of Unicode code points.
  *

package/fs/text/utf8/module.f.js

@@ -4,7 +4,7 @@
  * @module
  */
 import { flatMap, toArray } from "../../types/list/module.f.js";
-import { decoder, errorMask } from "../code_point/module.f.js";
+import { decoder, errorMask, isValidCodePoint } from "../code_point/module.f.js";
 import { msb, u8List, length } from "../../types/bit_vec/module.f.js";
 import { codePointListToString } from "../utf16/module.f.js";
 /**
@@ -106,7 +106,7 @@ export const fromCodePointList = flatMap(codePointToUtf8);
  * @param state - A non-empty UTF-8 decoding state.
  * @returns An I32 error code derived from the invalid UTF-8 state.
  */
-const utf8StateToError = (state) => {
+export const utf8StateToError = (state) => {
     let x;
     switch (state.length) {
         case 1: {
@@ -127,8 +127,8 @@ const utf8StateToError = (state) => {
                 contPayload(s2) + 0b1000_0000_0000_0000;
             break;
         }
-        default:
-            throw 'invalid state';
+        //default:
+        //    throw 'invalid state'
     }
     return x | errorMask;
 };
@@ -141,7 +141,7 @@ const utf8StateToError = (state) => {
  *   - A list of decoded Unicode code points or error codes.
  *   - The updated UTF-8 state.
  */
-const utf8ByteToCodePointOp = (byte, state) => {
+export const utf8ByteToCodePointOp = (byte, state) => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state];
     }
@@ -199,7 +199,7 @@ const utf8ByteToCodePointOp = (byte, state) => {
  *   - A list of decoded Unicode code points or error codes.
  *   - The reset UTF-8 state (`null`).
  */
-const utf8EofToCodePointOp = (state) => [
+export const utf8EofToCodePointOp = (state) => [
     state === null ? null : [utf8StateToError(state)],
     null,
 ];
@@ -216,18 +216,12 @@ export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePoint
  * code points.
  */
 export const fromVec = (v) => {
-    if (length(v) % 8n !== 0n) {
+    if ((length(v) & 7n) !== 0n) {
         return null;
     }
     const arr = toArray(toCodePointList(u8List(msb)(v)));
     for (const cp of arr) {
-        if (cp < 0) {
-            return null;
-        }
-        if (cp > 0x10FFFF) {
-            return null;
-        }
-        if (cp >= 0xD800 && cp <= 0xDFFF) {
+        if (!isValidCodePoint(cp)) {
             return null;
         }
     }

package/fs/types/function/operator/module.f.d.ts

@@ -12,6 +12,32 @@ export declare const logicalNot: Unary<boolean, boolean>;
 export type Equal<T> = Binary<T, T, boolean>;
 export declare const strictEqual: <T>(a: T) => (b: T) => boolean;
 export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
+/**
+ * One step of a stream transducer: given an `input` symbol and the `prior`
+ * state, produce an `output` and the next state. It both maps an input stream
+ * to an output stream and threads state, so it models tokenizers, decoders, and
+ * other stream-to-stream stages.
+ *
+ * This is the *shape* of a [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine)
+ * — a [finite-state transducer](https://en.wikipedia.org/wiki/Finite-state_transducer)
+ * — but only its signature. The state `S` (and `I`, `O`) is an arbitrary type,
+ * not a finite set, so a `StateScan` is strictly more expressive than a Mealy
+ * machine — its power is the power of `S`:
+ * - a finite `S`/`I`/`O` recovers the classical finite-state machine (e.g. the
+ *   DFA states in `../../../fsm/module.f.ts`);
+ * - an `S` that is a stack makes it a
+ *   [pushdown / stack machine](https://en.wikipedia.org/wiki/Pushdown_automaton)
+ *   (context-free power — balanced brackets, nested structure, the AST tier);
+ * - an unbounded `S` like `bigint` can count, which no finite automaton can.
+ *
+ * And `O` may be a list (0+ symbols per input), not the single symbol strict
+ * Mealy emits. (Functional/coalgebraic usage still calls this `(input, state)
+ * => [output, state]` shape a "Mealy machine", finiteness aside.)
+ *
+ * A {@link Fold} is the output-less special case (state only); driving a
+ * `StateScan` over a `List` is `stateScan` in `../../list/module.f.ts`, and
+ * {@link stateScanToScan} hides the state to recover a {@link Scan}.
+ */
 export type StateScan<I, S, O> = (input: I, prior: S) => readonly [O, S];
 export declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
 export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;

package/fs/types/list/module.f.d.ts

@@ -4,6 +4,9 @@ type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
 type Empty = null;
 export type Result<T> = Empty | NonEmpty<T>;
 export type Thunk<T> = () => List<T>;
+/**
+ * See also https://en.wikipedia.org/wiki/Cons#Lists
+ */
 export type NonEmpty<T> = {
     readonly first: T;
     readonly tail: List<T>;

package/fs/types/result/module.d.ts

@@ -1,5 +1,3 @@
 import { type Result } from './module.f.ts';
-declare const _default: {
-    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
-};
-export default _default;
+export declare const tryCatch: <T>(f: () => T) => Result<T, unknown>;
+export declare const asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;

package/fs/types/result/module.js

@@ -1,5 +1,5 @@
 import { ok, error } from "./module.f.js";
-const tryCatch = f => {
+export const tryCatch = f => {
     // Side effect: `try catch` is not allowed in FunctionalScript.
     try {
         return ok(f());
@@ -8,6 +8,12 @@ const tryCatch = f => {
         return error(e);
     }
 };
-export default {
-    tryCatch,
+export const asyncTryCatch = async (f) => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -43,8 +43,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@playwright/test": "1.61.0",
-    "@types/node": "26.0.0",
+    "@playwright/test": "1.61.1",
+    "@types/node": "26.0.1",
     "typescript": "6.0.3"
   }
 }

package/issues/demo/data/data.f.js

@@ -1,12 +0,0 @@
-import shared from "./shared.f.js"
-
-// comment
-const s = "Hello, world!"
-
-export default {
-  "a": shared,
-  "b": shared,
-  "s": s,
-  d: -24n,
-  x: undefined,
-}

package/issues/demo/data/shared.f.js

@@ -1,3 +0,0 @@
-export default {
-    "name": "shared object"
-}

package/issues/demo/fs/app.js

@@ -1,4 +0,0 @@
-import math from "./math.f.js"
-
-const add2 = math.add(2)
-console.log("5 ===", add2(3))

package/issues/demo/fs/math.f.js

@@ -1,4 +0,0 @@
-export default {
-  add: a => b => a + b,
-  mul: a => b => a * b,
-}

package/issues/demo/sample/proof.f.js

@@ -1,13 +0,0 @@
-const arrayOfTests = [
-  () => {
-    if (2 + 2 !== 4) throw "It's the end of the world as we know it!"
-  },
-  () => {
-    if (2n + 2n !== 4n) throw "It's the end of the world as we know it!"
-  }
-]
-
-export const proof = {
-  arrayOfTests,
-  generatingTests: () => arrayOfTests,
-}