functionalscript 0.3.15 → 0.4.1

package/fsc/json.f.d.ts

@@ -0,0 +1,7 @@
+import { type Rule, type TerminalRange } from '../bnf/func/module.f.ts';
+export declare const wsNoNewLine0: Rule;
+export declare const ws0: Rule;
+export declare const ws1: Rule;
+export declare const json: Rule;
+export declare const unicode: TerminalRange;
+export declare const digit: Rule;

package/fsc/json.f.js

@@ -0,0 +1,89 @@
+import { cp, join0, range, remove, repeat0, set, str } from "../bnf/func/module.f.js";
+// space
+const wsNoNewLineItem = () => set(' \t\r');
+export const wsNoNewLine0 = () => [
+    [],
+    [wsNoNewLineItem, wsNoNewLine0],
+];
+const wsItem = () => [
+    [wsNoNewLineItem],
+    str('\n'),
+];
+export const ws0 = () => [
+    [],
+    [ws1],
+];
+export const ws1 = () => [
+    [wsItem, ws0]
+];
+//
+export const json = () => [
+    [object],
+    [array],
+    [number],
+    [string],
+    str('true'),
+    str('false'),
+    str('null'),
+];
+//
+const separator = () => [[cp(','), ws0]];
+// object
+const member = () => [[string, ws0, cp(':'), ws0, json, ws0]];
+const object = () => [
+    [cp('{'), ws0, join0(member, separator), cp('}')]
+];
+// array
+const element = () => [
+    [json, ws0]
+];
+const array = () => [
+    [cp('['), ws0, join0(element, separator), cp(']')]
+];
+// string
+const character = () => [
+    ...remove(unicode, [cp('"'), cp('\\')]),
+    [cp('\\'), escape],
+];
+const string = () => [[cp('"'), repeat0(character), cp('"')]];
+export const unicode = [0x20, 0x10FFFF];
+const escape = () => [
+    ...set('"\\/bfnrt'),
+    [cp('u'), hex, hex, hex, hex] // 117
+];
+const hex = () => [
+    [digit],
+    [range('AF')],
+    [range('af')],
+];
+// number
+const number = () => [
+    [uNumber],
+    [cp('-'), uNumber],
+];
+const uNumber = () => [
+    [uint, fraction0, exponent0],
+];
+const uint = () => [
+    str('0'),
+    [range('19'), digits0]
+];
+export const digit = () => [[range('09')]];
+const digits0 = repeat0(digit);
+const digits1 = () => [
+    [digit, digits0]
+];
+const fraction0 = () => [
+    [],
+    [cp('.'), digits1]
+];
+const exponent0 = () => [
+    [],
+    [e, sign, digits1],
+];
+const e = () => set('eE');
+const sign = () => [
+    [],
+    [cp('+')],
+    [cp('-')],
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.15",
+  "version": "0.4.1",
   "type": "module",
   "files": [
     "**/*.f.d.ts",
@@ -13,7 +13,6 @@
     "test20": "npm run prepack && node --trace-uncaught ./dev/test.js",
     "test22": "tsc && node --experimental-strip-types --trace-uncaught ./dev/test.ts",
     "test": "tsc && node --trace-uncaught ./dev/test.ts",
-    "comtest": "node ./com/test/build.ts",
     "index": "node ./dev/index.ts",
     "version": "node ./nodejs/version/main.ts",
     "fsc": "node ./main.ts",
@@ -40,6 +39,6 @@
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
     "@types/node": "^22.10.5",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.3"
   }
 }

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

@@ -6,6 +6,7 @@
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
+export declare const isArray2: <T>(a: readonly T[]) => a is Array2<T>;
 export type Tuple2<T0, T1> = readonly [T0, T1];
 export type Index2 = 0 | 1;
 export type Array3<T> = readonly [T, T, T];

package/types/array/module.f.js

@@ -4,6 +4,7 @@
  * @module
  */
 import { map } from "../nullable/module.f.js";
+export const isArray2 = (a) => a.length === 2;
 const uncheckTail = (a) => a.slice(1);
 const uncheckHead = (a) => a.slice(0, -1);
 export const at = (i) => (a) => {

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

@@ -13,6 +13,7 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
+ * const m = min(3n)(13n) // 3n
  * ```
  */
 import { type Sign } from '../function/compare/module.f.ts';
@@ -42,6 +43,7 @@ export declare const serialize: (a: bigint) => string;
  *    of the most significant bit.
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
+ * 3. **Remainder Phase:** Using `Math.log2`.
  */
 export declare const log2: (v: bigint) => bigint;
 /**
@@ -78,3 +80,7 @@ export declare const bitLength: (v: bigint) => bigint;
  * ```
  */
 export declare const mask: (len: bigint) => bigint;
+/**
+ * A minimal value.
+ */
+export declare const min: (a: bigint) => (b: bigint) => bigint;

package/types/bigint/module.f.js

@@ -13,6 +13,7 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
+ * const m = min(3n)(13n) // 3n
  * ```
  */
 import { unsafeCmp } from "../function/compare/module.f.js";
@@ -39,13 +40,19 @@ export const serialize = (a) => `${a}n`;
  *    of the most significant bit.
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
+ * 3. **Remainder Phase:** Using `Math.log2`.
  */
 export const log2 = (v) => {
     if (v <= 0n) {
         return -1n;
     }
-    let result = 31n;
-    let i = 32n;
+    //
+    // 1. Fast Doubling.
+    //
+    let result = -1n;
+    // `bigints` higher than 2**1023 may lead to `Inf` during conversion to `number`.
+    // For example: `Number((1n << 1024n) - (1n << 970n)) === Inf`.
+    let i = 1023n;
     while (true) {
         const n = v >> i;
         if (n === 0n) {
@@ -56,9 +63,12 @@ export const log2 = (v) => {
         result += i;
         i <<= 1n;
     }
+    //
+    // 2. Binary Search.
+    //
     // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
-    // Because of this, We check if `i` is greater than 32 before we divide it by 2.
-    while (i !== 32n) {
+    // Because of this, We check if `i` is greater than 1023 before we divide it by 2.
+    while (i !== 1023n) {
         i >>= 1n;
         const n = v >> i;
         if (n !== 0n) {
@@ -66,7 +76,15 @@ export const log2 = (v) => {
             v = n;
         }
     }
-    return result - BigInt(Math.clz32(Number(v)));
+    //
+    // 3. Remainder Phase.
+    //
+    // We know that `v` is less than `1n << 1023` so we can calculate a remainder using
+    // `Math.log2`.
+    const rem = BigInt(Math.log2(Number(v)) | 0);
+    // (v >> rem) is either `0` or `1`, and it's used as a correction for
+    // Math.log2 rounding.
+    return result + rem + (v >> rem);
 };
 /**
  * Calculates the bit length of a given BigInt.
@@ -110,3 +128,7 @@ export const bitLength = (v) => {
  * ```
  */
 export const mask = (len) => (1n << len) - 1n;
+/**
+ * A minimal value.
+ */
+export const min = (a) => (b) => a < b ? a : b;

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

@@ -1,10 +1,13 @@
+export declare const clz32Log2: (v: bigint) => bigint;
 declare const _default: {
     example: () => void;
-    benchmark: {
-        str: () => void;
-        stringHexLog2: () => void;
-        oldLog2: () => void;
-        log2: () => void;
+    benchmark: () => {
+        big: {
+            [k: string]: () => void;
+        };
+        small: {
+            [k: string]: () => void;
+        };
     };
     mask: () => void;
     sum: () => void;

package/types/bigint/test.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, min } from "./module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;
@@ -27,24 +27,83 @@ const oldLog2 = (v) => {
     }
     return result;
 };
-const stringLog2 = (v) => BigInt(v.toString(2).length) - 1n;
-const stringHexLog2 = (v) => {
+const strBinLog2 = (v) => BigInt(v.toString(2).length) - 1n;
+const strHexLog2 = (v) => {
     const len = (BigInt(v.toString(16).length) - 1n) << 2n;
-    const x = v >> len;
-    return len + 31n - BigInt(Math.clz32(Number(x)));
+    return len + 31n - BigInt(Math.clz32(Number(v >> len)));
 };
-const benchmark = (f) => () => {
+const str32Log2 = (v) => {
+    const len = (BigInt(v.toString(32).length) - 1n) * 5n;
+    return len + 31n - BigInt(Math.clz32(Number(v >> len)));
+};
+export const clz32Log2 = (v) => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    let result = 31n;
+    let i = 32n;
+    while (true) {
+        const n = v >> i;
+        if (n === 0n) {
+            // overshot
+            break;
+        }
+        v = n;
+        result += i;
+        i <<= 1n;
+    }
+    // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
+    // Because of this, We check if `i` is greater than 32 before we divide it by 2.
+    while (i !== 32n) {
+        i >>= 1n;
+        const n = v >> i;
+        if (n !== 0n) {
+            result += i;
+            v = n;
+        }
+    }
+    return result - BigInt(Math.clz32(Number(v)));
+};
+const benchmark = f => () => {
     let e = 1048575n;
     let c = 1n << e;
-    for (let i = 0n; i < 1_000; ++i) {
-        const x = f(c);
-        if (x !== e) {
-            throw x;
+    for (let i = 0n; i < 1_100; ++i) {
+        {
+            const x = f(c);
+            if (x !== e) {
+                throw x;
+            }
+        }
+        {
+            const x = f(c - 1n);
+            if (x !== e - 1n) {
+                throw [e, x];
+            }
         }
         c >>= 1n;
         --e;
     }
 };
+const benchmarkSmall = f => () => {
+    let e = 2000n;
+    let c = 1n << e;
+    do {
+        {
+            const x = f(c);
+            if (x !== e) {
+                throw [e, x];
+            }
+        }
+        for (let j = 1n; j < min(c >> 1n)(1000n); ++j) {
+            const x = f(c - j);
+            if (x !== e - 1n) {
+                throw [j, e, x];
+            }
+        }
+        c >>= 1n;
+        --e;
+    } while (c !== 0n);
+};
 export default {
     example: () => {
         const total = sum([1n, 2n, 3n]); // 6n
@@ -53,26 +112,39 @@ export default {
         }
         const absoluteValue = abs(-42n); // 42n
         if (absoluteValue !== 42n) {
-            throw total;
+            throw absoluteValue;
         }
         const logValue = log2(8n); // 3n
         if (logValue !== 3n) {
-            throw total;
+            throw logValue;
         }
         const bitCount = bitLength(255n); // 8n
         if (bitCount !== 8n) {
-            throw total;
+            throw bitCount;
         }
         const bitmask = mask(5n); // 31n
         if (bitmask !== 31n) {
-            throw total;
+            throw benchmark;
+        }
+        const m = min(3n)(13n); // 3n
+        if (m !== 3n) {
+            throw m;
         }
     },
-    benchmark: {
-        str: benchmark(stringLog2),
-        stringHexLog2: benchmark(stringHexLog2),
-        oldLog2: benchmark(oldLog2),
-        log2: benchmark(log2),
+    benchmark: () => {
+        const list = {
+            strBinLog2,
+            strHexLog2,
+            str32Log2,
+            oldLog2,
+            clz32Log2,
+            log2,
+        };
+        const transform = (b) => Object.fromEntries(Object.entries(list).map(([k, f]) => [k, b(f)]));
+        return {
+            big: transform(benchmark),
+            small: transform(benchmarkSmall),
+        };
     },
     mask: () => {
         const result = mask(3n); // 7n

package/com/cpp/module.f.d.ts

@@ -1,10 +0,0 @@
-/**
- * This module generates C++ code blocks, including structs, interfaces, and method headers,
- * based on a COM library of type definitions.
- */
-import { type Library } from '../types/module.f.ts';
-import * as text from '../../text/module.f.ts';
-/**
- * Generates the C++ code for a library.
- */
-export declare const cpp: (name: string) => (lib: Library) => text.Block;

package/com/cpp/module.f.js

@@ -1,106 +0,0 @@
-/**
- * This module generates C++ code blocks, including structs, interfaces, and method headers,
- * based on a COM library of type definitions.
- */
-import { paramList, result, } from "../types/module.f.js";
-import * as text from "../../text/module.f.js";
-import { map, flatMap, flat } from "../../types/list/module.f.js";
-import { join } from "../../types/string/module.f.js";
-const { entries } = Object;
-const struct = (name) => (body) => [`struct ${name}`, '{', body, '};'];
-const baseTypeMap = {
-    u8: 'uint8_t',
-    i8: 'int8_t',
-    u16: 'uint16_t',
-    i16: 'int16_t',
-    u32: 'uint32_t',
-    i32: 'int32_t',
-    u64: 'uint64_t',
-    i64: 'int64_t',
-    usize: 'size_t',
-    isize: 'ptrdiff_t',
-    f32: 'float',
-    f64: 'double',
-    bool: 'bool',
-};
-const baseType = (t) => baseTypeMap[t];
-const resultVoid = result('void');
-const namespace = text.curly('namespace');
-const comRef = (id) => `::nanocom::ref<${id}>`;
-const ptr = (id) => `${id} const*`;
-const ref = (id) => `${id} const&`;
-const paramName = ([name]) => name;
-const mapParamName = map(paramName);
-const joinComma = join(', ');
-/**
- * Generates the C++ code for a library.
- */
-export const cpp = (name) => (lib) => {
-    const interface_ = (t) => {
-        if (!(t instanceof Array) || t.length !== 1) {
-            return null;
-        }
-        const [name] = t;
-        return 'interface' in lib[name] ? name : null;
-    };
-    const objectType = (i) => (t) => {
-        if (typeof (t) === 'string') {
-            return baseType(t);
-        }
-        if (t.length === 2) {
-            return `${type(t[1])} const*`;
-        }
-        const [id] = t;
-        return 'interface' in lib[id] ? i(id) : id;
-    };
-    const type = objectType(comRef);
-    const resultType = objectType(ptr);
-    const field = ([name, t]) => `${type(t)} ${name};`;
-    const mapField = map(field);
-    const defStruct = (s) => mapField(entries(s.struct));
-    const cppResult = resultVoid(resultType);
-    const param = ([name, t]) => `${objectType(ref)(t)} ${name}`;
-    const mapParam = map(param);
-    const methodHeader = (result) => (paramArrayStr) => (name) => `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`;
-    const method = ([name, paramArray]) => {
-        const result = cppResult(paramArray);
-        const paramL = paramList(paramArray);
-        const paramArrayStr = `(${joinComma(mapParam(paramL))})`;
-        const m = methodHeader(result)(paramArrayStr);
-        const resultName = interface_(paramArray._);
-        if (resultName === null) {
-            return [m(name)];
-        }
-        return [
-            m(`${name}_`),
-            `${comRef(resultName)} ${name}${paramArrayStr} const noexcept`,
-            '{',
-            [`return ::nanocom::move_to_ref(${name}_(${joinComma(mapParamName(paramL))}));`],
-            '}',
-        ];
-    };
-    const mapMethod = flatMap(method);
-    const defInterface = ({ guid, interface: i }) => {
-        const g = guid.replaceAll('-', '');
-        const lo = g.substring(0, 16);
-        const hi = g.substring(16);
-        return flat([
-            [`constexpr static ::nanocom::GUID const guid = ::nanocom::GUID(0x${lo}, 0x${hi});`],
-            mapMethod(entries(i))
-        ]);
-    };
-    const def = ([name, d]) => 'interface' in d ?
-        [`class ${name} : public ::nanocom::IUnknown`,
-            '{',
-            'public:',
-            defInterface(d),
-            '};'
-        ] :
-        struct(name)(defStruct(d));
-    const forward = ([name]) => [`struct ${name};`];
-    const e = entries(lib);
-    return flat([
-        ['#pragma once', ''],
-        namespace(name)(flat([flatMap(forward)(e), flatMap(def)(e)]))
-    ]);
-};

package/com/cpp/test.f.d.ts

@@ -1,2 +0,0 @@
-declare const f: () => void;
-export default f;

package/com/cpp/test.f.js

@@ -1,40 +0,0 @@
-import cpp from "./testlib.f.js";
-const f = () => {
-    const e = '#pragma once\n' +
-        '\n' +
-        'namespace My\n' +
-        '{\n' +
-        '    struct Slice;\n' +
-        '    struct ManagedStruct;\n' +
-        '    struct IMy;\n' +
-        '    struct Slice\n' +
-        '    {\n' +
-        '        uint8_t const* Start;\n' +
-        '        size_t Size;\n' +
-        '    };\n' +
-        '    struct ManagedStruct\n' +
-        '    {\n' +
-        '        ::nanocom::ref<IMy> M;\n' +
-        '    };\n' +
-        '    class IMy : public ::nanocom::IUnknown\n' +
-        '    {\n' +
-        '    public:\n' +
-        '        constexpr static ::nanocom::GUID const guid = ::nanocom::GUID(0xC66FB2702D8049AD, 0xBB6E88C1F90B805D);\n' +
-        '        virtual Slice GetSlice() const noexcept = 0;\n' +
-        '        virtual void SetSlice(Slice slice) const noexcept = 0;\n' +
-        '        virtual bool const* GetUnsafe() const noexcept = 0;\n' +
-        '        virtual void SetUnsafe(Slice const* p, uint32_t size) const noexcept = 0;\n' +
-        '        virtual bool Some(IMy const& p) const noexcept = 0;\n' +
-        '        virtual IMy const* GetIMy_(uint16_t a, int16_t b) const noexcept = 0;\n' +
-        '        ::nanocom::ref<IMy> GetIMy(uint16_t a, int16_t b) const noexcept\n' +
-        '        {\n' +
-        '            return ::nanocom::move_to_ref(GetIMy_(a, b));\n' +
-        '        }\n' +
-        '        virtual void SetManagedStruct(ManagedStruct a) const noexcept = 0;\n' +
-        '    };\n' +
-        '}';
-    if (cpp() !== e) {
-        throw cpp;
-    }
-};
-export default f;

package/com/cpp/testlib.f.d.ts

@@ -1,2 +0,0 @@
-declare const _default: () => string;
-export default _default;

package/com/cpp/testlib.f.js

@@ -1,5 +0,0 @@
-import { join } from "../../types/string/module.f.js";
-import { flat } from "../../text/module.f.js";
-import library from "../types/testlib.f.js";
-import { cpp } from "./module.f.js";
-export default () => join('\n')(flat('    ')(cpp('My')(library)));

package/com/cs/module.f.d.ts

@@ -1,12 +0,0 @@
-/**
- * This module generates C# code blocks for COM interop from a high-level type library definition.
- *
- * The module maps type definitions (e.g., structs, interfaces, and methods) into C# constructs
- * with appropriate attributes for COM interop, such as `[StructLayout]`, `[Guid]`, and `[InterfaceType]`.
- */
-import { type Library } from '../types/module.f.ts';
-import { type Block } from '../../text/module.f.ts';
-/**
- * Generates the C# code for a library.
- */
-export declare const cs: (name: string) => (library: Library) => Block;

package/com/cs/module.f.js

@@ -1,79 +0,0 @@
-/**
- * This module generates C# code blocks for COM interop from a high-level type library definition.
- *
- * The module maps type definitions (e.g., structs, interfaces, and methods) into C# constructs
- * with appropriate attributes for COM interop, such as `[StructLayout]`, `[Guid]`, and `[InterfaceType]`.
- */
-import { result, paramList, } from "../types/module.f.js";
-import { curly } from "../../text/module.f.js";
-import { flat, map, some, flatMap } from "../../types/list/module.f.js";
-import { join } from "../../types/string/module.f.js";
-const { entries } = Object;
-const using = (v) => `using ${v};`;
-const typeDef = (attributes) => (type) => (name) => (body) => flat([
-    map(v => `[${v}]`)(attributes),
-    curly(`public ${type}`)(name)(body)
-]);
-const baseTypeMap = {
-    bool: 'byte',
-    f32: 'float',
-    f64: 'double',
-    i16: 'short',
-    i32: 'int',
-    i64: 'long',
-    i8: 'sbyte',
-    isize: 'IntPtr',
-    u16: 'ushort',
-    u32: 'uint',
-    u64: 'ulong',
-    u8: 'byte',
-    usize: 'UIntPtr',
-};
-const baseType = (t) => baseTypeMap[t];
-const unsafe = (isUnsafe) => isUnsafe ? 'unsafe ' : '';
-const fullType = (t) => typeof (t) === 'string' ?
-    [false, baseType(t)] :
-    t.length === 1 ?
-        [false, t[0]] :
-        [true, `${type(t[1])}*`];
-const type = (t) => fullType(t)[1];
-const param = ([name, t]) => `${type(t)} ${name}`;
-const mapParam = map(param);
-const field = ([name, comType]) => {
-    const [isUnsafe, t] = fullType(comType);
-    return `public ${unsafe(isUnsafe)}${t} ${name};`;
-};
-const isUnsafeField = (field) => fullType(field[1])[0];
-const mapIsUnsafeField = map(isUnsafeField);
-const resultVoid = result('void');
-const joinComma = join(', ');
-const method = ([name, m]) => {
-    const paramAndResultList = entries(m);
-    const pl = paramList(m);
-    const isUnsafe = some(mapIsUnsafeField(paramAndResultList));
-    return [
-        '[PreserveSig]',
-        `${unsafe(isUnsafe)}${resultVoid(type)(m)} ${name}(${joinComma(mapParam(pl))});`
-    ];
-};
-const struct = typeDef(['StructLayout(LayoutKind.Sequential)'])('struct');
-const mapField = map(field);
-const flatMapMethod = flatMap(method);
-const def = ([n, d]) => !('interface' in d) ?
-    struct(n)(mapField(entries(d.struct))) :
-    typeDef([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])('interface')(n)(flatMapMethod(entries(d.interface)));
-const flatMapDef = flatMap(def);
-const namespace = curly('namespace');
-const header = [
-    using('System'),
-    using('System.Runtime.InteropServices'),
-    ''
-];
-/**
- * Generates the C# code for a library.
- */
-export const cs = (name) => (library) => {
-    const v = flatMapDef(entries(library));
-    const ns = namespace(name)(v);
-    return flat([header, ns]);
-};

package/com/cs/test.f.d.ts

@@ -1,2 +0,0 @@
-declare const f: () => void;
-export default f;