functionalscript 0.3.11 → 0.3.12

package/nanvm-lib/tests/test.f.d.ts

@@ -41,6 +41,9 @@ declare const _default: {
             positive: () => void;
             nan: () => void;
         };
+        bigint: {
+            throw: () => number;
+        };
         array: {
             empty: () => void;
             single_number: () => void;
@@ -50,6 +53,7 @@ declare const _default: {
         object: {
             empty: () => void;
         };
+        function: () => void;
     };
 };
 export default _default;

package/nanvm-lib/tests/test.f.js

@@ -108,11 +108,9 @@ export default {
                 positive: () => e(op("2.3"))(2.3),
                 nan: () => nan("a")
             },
-            // TODO: bigint - handle TypeError exception for bigint. The test below (that follows
-            // current Rust implementation) is incorrect.
-            // bigint: {
-            //     nan: () => u_p_nan(0n)
-            // }
+            bigint: {
+                throw: () => op(0n),
+            },
             array: {
                 empty: () => e(op([]))(0),
                 single_number: () => e(op([2.3]))(2.3),
@@ -122,8 +120,8 @@ export default {
             object: {
                 empty: () => nan({})
                 // TODO: test objects with valueOf, toString functions - when Rust logic is implemented
-            }
-            // TODO: test Function - when Rust logic is implemented
+            },
+            function: () => nan(op(() => { }))
         };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/text/module.f.js

@@ -1,7 +1,7 @@
 import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
 import { flatMap } from "../types/list/module.f.js";
 import * as utf8 from "./utf8/module.f.js";
-import * as utf16 from "./utf16/module.f.js";
+import { stringToCodePointList, codePointListToString } from "./utf16/module.f.js";
 export const flat = (indent) => {
     const f = (prefix) => {
         const g = (item) => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
@@ -16,11 +16,11 @@ export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(utf16.toCodePointList(utf16.stringToList(s))));
+export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(stringToCodePointList(s)));
 /**
  * Converts a UTF-8 bit vector with MSB first encoding to a string.
  *
  * @param msbV - The UTF-8 bit vector with MSB first encoding.
  * @returns The resulting string.
  */
-export const msbUtf8ToString = (msbV) => utf16.listToString(utf16.fromCodePointList(utf8.toCodePointList(u8List(msb)(msbV))));
+export const msbUtf8ToString = (msbV) => codePointListToString(utf8.toCodePointList(u8List(msb)(msbV)));

package/text/utf16/module.f.d.ts

@@ -1,8 +1,14 @@
 import { type List, type Thunk } from '../../types/list/module.f.ts';
-type U16 = number;
-type I32 = number;
-export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
-export declare const toCodePointList: (input: List<U16>) => List<I32>;
+export type U16 = number;
+/**
+ * [0, 0x10_FFFF]: 16+5 = 21 bits
+ *
+ * 121_0000_0000: 16+16+9 = 41 bits
+ */
+export type CodePoint = number;
+export declare const fromCodePointList: (input: List<CodePoint>) => Thunk<U16>;
+export declare const toCodePointList: (input: List<U16>) => List<CodePoint>;
 export declare const stringToList: (s: string) => List<U16>;
+export declare const stringToCodePointList: (input: string) => List<CodePoint>;
 export declare const listToString: (input: List<U16>) => string;
-export {};
+export declare const codePointListToString: (input: List<CodePoint>) => string;

package/text/utf16/module.f.js

@@ -60,6 +60,8 @@ export const stringToList = (s) => {
     };
     return at(0);
 };
+export const stringToCodePointList = (input) => toCodePointList(stringToList(input));
 export const listToString = fn(map(String.fromCharCode))
     .then(reduce(concat)(''))
     .result;
+export const codePointListToString = (input) => listToString(fromCodePointList(input));

package/text/utf16/test.f.js

@@ -1,4 +1,4 @@
-import { toCodePointList, fromCodePointList, stringToList, listToString } from "./module.f.js";
+import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from "./module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
@@ -130,6 +130,13 @@ export default {
                 throw result;
             }
         },
+        () => {
+            const cpList = stringToCodePointList("Hello world!😂🚜🚲");
+            const result = codePointListToString(cpList);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        },
         () => {
             const a = stringToList("Hello world!😂🚜🚲");
             const b = toCodePointList(a);

package/types/range_map/module.f.d.ts

@@ -1,14 +1,91 @@
+/**
+ * Utility functions and types for managing and merging range maps.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * const rmOps = rangeMap({
+ *     union: a => b => a | b,
+ *     equal: a => b => a === b,
+ *     def: 0,
+ * })
+ *
+ * // Create range maps
+ * const range1 = rmOps.fromRange([0, 10])(2)
+ * const range2 = rmOps.fromRange([5, 15])(5)
+ *
+ * // Merge range maps
+ * const merged = toArray(rmOps.merge(range1)(range2))
+ *
+ * // Retrieve values from the merged range map
+ * //
+ * if (rmOps.get(-1)(merged) !== 0) { throw 'error' }
+ * //
+ * if (rmOps.get(0)(merged) !== 2) { throw 'error' }
+ * if (rmOps.get(2)(merged) !== 2) { throw 'error' }
+ * // overlapped: 2 | 5 = 7
+ * if (rmOps.get(7)(merged) !== 7) { throw 'error' }
+ * //
+ * if (rmOps.get(12)(merged) !== 5) { throw 'error' }
+ * if (rmOps.get(15)(merged) !== 5) { throw 'error' }
+ * //
+ * if (rmOps.get(16)(merged) !== 0) { throw 'error' }
+ * ```
+ */
 import { type SortedList } from '../sorted_list/module.f.ts';
 import type { Reduce, Equal } from '../function/operator/module.f.ts';
 import type { Range } from '../range/module.f.ts';
 export type Entry<T> = [T, number];
+/**
+ * A sorted list of entries, where each entry is a tuple `[T, number]` that maps a value of type `T` to an upper boundary
+ * of a numeric range.
+ */
 export type RangeMap<T> = SortedList<Entry<T>>;
 export type RangeMapArray<T> = readonly Entry<T>[];
-export type Operators<T> = {
+/**
+ * Defines the properties and operations required for managing range maps.
+ */
+export type Properties<T> = {
+    /**
+     * A function to merge two values of type `T`. This defines how overlapping ranges are combined.
+     */
     readonly union: Reduce<T>;
+    /**
+     * A function to check equality between two values of type `T`.
+     */
     readonly equal: Equal<T>;
+    /**
+     * The default value used when no range matches or for initializing ranges.
+     */
+    readonly def: T;
 };
 export type RangeMerge<T> = Reduce<RangeMap<T>>;
-export declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
+export declare const merge: <T>(op: Properties<T>) => RangeMerge<T>;
 export declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
 export declare const fromRange: <T>(def: T) => (r: Range) => (value: T) => RangeMapArray<T>;
+/**
+ * Represents a set of operations for managing range maps.
+ */
+export type RangeMapOp<T> = {
+    /**
+     * Merges two range maps into a single range map.
+     */
+    readonly merge: RangeMerge<T>;
+    /**
+     * Retrieves the value associated with a given numeric range.
+     */
+    readonly get: (value: number) => (rm: RangeMapArray<T>) => T;
+    /**
+     * Constructs a range map for a single numeric range and value.
+     */
+    readonly fromRange: (r: Range) => (value: T) => RangeMapArray<T>;
+};
+/**
+ * Creates a set of operations for managing range maps using the specified properties.
+ *
+ * @param op - The properties defining union and equality operations and the default value.
+ * @returns An object containing operations for merging, retrieving, and constructing range maps.
+ */
+export declare const rangeMap: <T>(op: Properties<T>) => RangeMapOp<T>;

package/types/range_map/module.f.js

@@ -1,7 +1,43 @@
+/**
+ * Utility functions and types for managing and merging range maps.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * const rmOps = rangeMap({
+ *     union: a => b => a | b,
+ *     equal: a => b => a === b,
+ *     def: 0,
+ * })
+ *
+ * // Create range maps
+ * const range1 = rmOps.fromRange([0, 10])(2)
+ * const range2 = rmOps.fromRange([5, 15])(5)
+ *
+ * // Merge range maps
+ * const merged = toArray(rmOps.merge(range1)(range2))
+ *
+ * // Retrieve values from the merged range map
+ * //
+ * if (rmOps.get(-1)(merged) !== 0) { throw 'error' }
+ * //
+ * if (rmOps.get(0)(merged) !== 2) { throw 'error' }
+ * if (rmOps.get(2)(merged) !== 2) { throw 'error' }
+ * // overlapped: 2 | 5 = 7
+ * if (rmOps.get(7)(merged) !== 7) { throw 'error' }
+ * //
+ * if (rmOps.get(12)(merged) !== 5) { throw 'error' }
+ * if (rmOps.get(15)(merged) !== 5) { throw 'error' }
+ * //
+ * if (rmOps.get(16)(merged) !== 0) { throw 'error' }
+ * ```
+ */
 import { genericMerge } from "../sorted_list/module.f.js";
 import { next } from "../list/module.f.js";
 import { cmp } from "../number/module.f.js";
-const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
+const reduceOp = ({ union, equal }) => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax);
     const min = sign === 1 ? bMax : aMax;
     const u = union(aItem)(bItem);
@@ -21,7 +57,7 @@ const tailReduce = equal => state => tail => {
     }
     return { first: state, tail: tailResult };
 };
-export const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null);
+export const merge = op => genericMerge({ reduceOp: reduceOp(op), tailReduce: tailReduce(op.equal) })(null);
 export const get = def => value => rm => {
     const len = rm.length;
     let b = 0;
@@ -43,3 +79,14 @@ export const get = def => value => rm => {
     }
 };
 export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]];
+/**
+ * Creates a set of operations for managing range maps using the specified properties.
+ *
+ * @param op - The properties defining union and equality operations and the default value.
+ * @returns An object containing operations for merging, retrieving, and constructing range maps.
+ */
+export const rangeMap = (op) => ({
+    merge: merge(op),
+    get: get(op.def),
+    fromRange: fromRange(op.def),
+});

package/types/range_map/test.f.d.ts

@@ -1,4 +1,5 @@
 declare const _default: {
+    example: () => void;
     merge: (() => void)[];
     get: () => (() => void)[];
     fromRange: () => (() => void)[];

package/types/range_map/test.f.js

@@ -1,19 +1,62 @@
-import { get, merge, fromRange } from "./module.f.js";
+import { get, merge, fromRange, rangeMap } from "./module.f.js";
 import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
-import * as sortedSet from "../sorted_set/module.f.js";
-import * as list from "../list/module.f.js";
+import { union } from "../sorted_set/module.f.js";
+import { equal, toArray } from "../list/module.f.js";
 import * as operator from "../function/operator/module.f.js";
 const stringify = json.stringify(sort);
-const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) };
+const op = {
+    union: union(unsafeCmp),
+    equal: equal(operator.strictEqual),
+    def: []
+};
 export default {
+    example: () => {
+        const rmOps = rangeMap({
+            union: a => b => a | b,
+            equal: a => b => a === b,
+            def: 0,
+        });
+        // Create range maps
+        const range1 = rmOps.fromRange([0, 10])(2);
+        const range2 = rmOps.fromRange([5, 15])(5);
+        // Merge range maps
+        const merged = toArray(rmOps.merge(range1)(range2));
+        // Retrieve values from the merged range map
+        //
+        if (rmOps.get(-1)(merged) !== 0) {
+            throw 'error';
+        }
+        //
+        if (rmOps.get(0)(merged) !== 2) {
+            throw 'error';
+        }
+        if (rmOps.get(2)(merged) !== 2) {
+            throw 'error';
+        }
+        // 2 | 5 = 7
+        if (rmOps.get(7)(merged) !== 7) {
+            throw 'error';
+        }
+        //
+        if (rmOps.get(12)(merged) !== 5) {
+            throw 'error';
+        }
+        if (rmOps.get(15)(merged) !== 5) {
+            throw 'error';
+        }
+        //
+        if (rmOps.get(16)(merged) !== 0) {
+            throw 'error';
+        }
+    },
     merge: [
         () => {
             const a = [[['a'], 1], [['b'], 2]];
             const b = null;
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
             }
@@ -22,7 +65,7 @@ export default {
             const a = null;
             const b = [[['a'], 1], [['b'], 2]];
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
             }
@@ -31,7 +74,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['a'], 1], [['b'], 2]];
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
             }
@@ -40,7 +83,7 @@ export default {
             const a = [[['a'], 1], [['c'], 3]];
             const b = [[['b'], 2], [['d'], 4]];
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') {
                 throw result;
             }
@@ -49,7 +92,7 @@ export default {
             const a = [[['a'], 1], [['d'], 4]];
             const b = [[['b'], 2], [['c'], 3]];
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') {
                 throw result;
             }
@@ -58,7 +101,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['b'], 1], [['a'], 2]];
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a","b"],2]]') {
                 throw result;
             }
@@ -67,7 +110,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
             const b = [[['a'], 5]];
             const merged = merge(op)(a)(b);
-            const result = stringify(list.toArray(merged));
+            const result = stringify(toArray(merged));
             if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') {
                 throw result;
             }

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

@@ -1,6 +1,53 @@
+/**
+ * A module for representing and handling operations that can succeed or fail.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { error, ok, unwrap, type Result } from './module.f.ts'
+ *
+ * const success: Result<number, string> = ok(42)
+ * const failure: Result<number, string> = error('Something went wrong')
+ *
+ * if (unwrap(success) !== 42) { throw 'error' }
+ * const [kind, v] = failure
+ * if (kind !== 'error') { throw 'error' }
+ * // `v` is inferred as `string` here
+ * if (v !== 'Something went wrong') { throw 'error' }
+ * ```
+ */
+/**
+ * Represents a successful result.
+ */
 export type Ok<T> = readonly ['ok', T];
+/**
+ * Represents a failed result.
+ */
 export type Error<E> = readonly ['error', E];
+/**
+ * Represents a result that can be either successful or failed.
+ */
 export type Result<T, E> = Ok<T> | Error<E>;
+/**
+ * Creates a successful result.
+ *
+ * @param value - The value to wrap.
+ * @returns A successful result containing the value.
+ */
 export declare const ok: <T>(value: T) => Ok<T>;
+/**
+ * Creates a failed result.
+ *
+ * @param e - The error to wrap.
+ * @returns A failed result containing the error.
+ */
 export declare const error: <E>(e: E) => Error<E>;
-export declare const unwrap: <T, E>(r: Result<T, E>) => T;
+/**
+ * Unwraps a result, returning the value if successful or throwing the error if failed.
+ *
+ * @param param0 - The result to unwrap.
+ * @returns The value if the result is successful. Otherwise, throws the error.
+ */
+export declare const unwrap: <T, E>([kind, v]: Result<T, E>) => T;

package/types/result/module.f.js

@@ -1,5 +1,43 @@
-export const ok = value => ['ok', value];
-export const error = e => ['error', e];
+/**
+ * A module for representing and handling operations that can succeed or fail.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { error, ok, unwrap, type Result } from './module.f.ts'
+ *
+ * const success: Result<number, string> = ok(42)
+ * const failure: Result<number, string> = error('Something went wrong')
+ *
+ * if (unwrap(success) !== 42) { throw 'error' }
+ * const [kind, v] = failure
+ * if (kind !== 'error') { throw 'error' }
+ * // `v` is inferred as `string` here
+ * if (v !== 'Something went wrong') { throw 'error' }
+ * ```
+ */
+/**
+ * Creates a successful result.
+ *
+ * @param value - The value to wrap.
+ * @returns A successful result containing the value.
+ */
+export const ok = (value) => ['ok', value];
+/**
+ * Creates a failed result.
+ *
+ * @param e - The error to wrap.
+ * @returns A failed result containing the error.
+ */
+export const error = (e) => ['error', e];
+/**
+ * Unwraps a result, returning the value if successful or throwing the error if failed.
+ *
+ * @param param0 - The result to unwrap.
+ * @returns The value if the result is successful. Otherwise, throws the error.
+ */
 export const unwrap = ([kind, v]) => {
     if (kind === 'error') {
         throw v;

package/types/result/test.f.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    example: () => void;
+};
+export default _default;

package/types/result/test.f.js

@@ -0,0 +1,18 @@
+import { error, ok, unwrap } from "./module.f.js";
+export default {
+    example: () => {
+        const success = ok(42);
+        const failure = error('Something went wrong');
+        if (unwrap(success) !== 42) {
+            throw 'error';
+        }
+        const [kind, v] = failure;
+        if (kind !== 'error') {
+            throw 'error';
+        }
+        // `v` is inferred as `string` here
+        if (v !== 'Something went wrong') {
+            throw 'error';
+        }
+    }
+};

package/types/sorted_list/module.f.js

@@ -28,14 +28,15 @@ const cmpReduce = (cmp) => () => a => b => {
 };
 const mergeTail = () => identity;
 export const find = (cmp) => (value) => (array) => {
+    const cmpValue = cmp(value);
     let b = 0;
     let e = array.length - 1;
     while (true) {
-        if (e - b < 0)
+        const d = e - b;
+        if (d < 0)
             return null;
-        const mid = b + (e - b >> 1);
-        const sign = cmp(value)(array[mid]);
-        switch (sign) {
+        const mid = b + (d >> 1);
+        switch (cmpValue(array[mid])) {
             case -1: {
                 e = mid - 1;
                 break;