functionalscript 0.3.14 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.14",
+  "version": "0.4.0",
   "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/bit_vec/module.f.js

@@ -1,14 +1,15 @@
 /**
- * @module
- * @description
- * ```
  * MSb is most-significant bit first.
+ * ```
  * - byte: 0x53 = 0b0101_0011
- * -              0123_4567
+ * -                0123_4567
+ * ```
  * LSb is least-significant bit first.
+ * ```
  * - byte: 0x53 = 0b0101_0011
- * -              7654_3210
+ * -                7654_3210
  * ```
+ * @module
  */
 import { log2, mask } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";

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;

package/com/cs/test.f.js

@@ -1,43 +0,0 @@
-import cs from "./testlib.f.js";
-const f = () => {
-    const e = 'using System;\n' +
-        'using System.Runtime.InteropServices;\n' +
-        '\n' +
-        'namespace My\n' +
-        '{\n' +
-        '    [StructLayout(LayoutKind.Sequential)]\n' +
-        '    public struct Slice\n' +
-        '    {\n' +
-        '        public unsafe byte* Start;\n' +
-        '        public UIntPtr Size;\n' +
-        '    }\n' +
-        '    [StructLayout(LayoutKind.Sequential)]\n' +
-        '    public struct ManagedStruct\n' +
-        '    {\n' +
-        '        public IMy M;\n' +
-        '    }\n' +
-        '    [Guid("C66FB270-2D80-49AD-BB6E-88C1F90B805D")]\n' +
-        '    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]\n' +
-        '    public interface IMy\n' +
-        '    {\n' +
-        '        [PreserveSig]\n' +
-        '        Slice GetSlice();\n' +
-        '        [PreserveSig]\n' +
-        '        void SetSlice(Slice slice);\n' +
-        '        [PreserveSig]\n' +
-        '        unsafe byte* GetUnsafe();\n' +
-        '        [PreserveSig]\n' +
-        '        unsafe void SetUnsafe(Slice* p, uint size);\n' +
-        '        [PreserveSig]\n' +
-        '        byte Some(IMy p);\n' +
-        '        [PreserveSig]\n' +
-        '        IMy GetIMy(ushort a, short b);\n' +
-        '        [PreserveSig]\n' +
-        '        void SetManagedStruct(ManagedStruct a);\n' +
-        '    }\n' +
-        '}';
-    if (cs !== e) {
-        throw cs;
-    }
-};
-export default f;

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

@@ -1,2 +0,0 @@
-declare const _default: string;
-export default _default;

package/com/cs/testlib.f.js

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

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

@@ -1,15 +0,0 @@
-/**
- * This module generates Rust code for COM interop from a high-level type library definition.
- *
- * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interpretation.
- */
-import { type Library } from '../types/module.f.ts';
-import type * as text from '../../text/module.f.ts';
-/**
- * Generates Rust code for the given type library.
- *
- * @param library - The library of type definitions to generate Rust code for.
- * @returns A block of Rust code representing the library.
- */
-export declare const rust: (library: Library) => text.Block;

package/com/rust/module.f.js

@@ -1,164 +0,0 @@
-/**
- * This module generates Rust code for COM interop from a high-level type library definition.
- *
- * The module provides functions to define structs, traits, and implementations in Rust,
- * specifically tailored for `nanocom` interpretation.
- */
-import { paramList } from "../types/module.f.js";
-import { flat, map, flatMap } from "../../types/list/module.f.js";
-import { fn } from "../../types/function/module.f.js";
-import { join } from "../../types/string/module.f.js";
-const { entries } = Object;
-const rustField = (field) => `pub ${field},`;
-const mapRustField = map(rustField);
-const rustStruct = (b) => (name) => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`];
-const commaJoin = join(', ');
-const ref = (name) => `${name}::Ref`;
-const obj = (name) => `&${name}::Object`;
-const self = ['&self'];
-const paramName = ([n]) => n;
-const callList = (p) => map(paramName)(paramList(p));
-const call = (p) => commaJoin(callList(p));
-const virtualCall = (p) => commaJoin(flat([['self'], callList(p)]));
-const super_ = 'super::';
-const assign = ([n]) => `${n}: Self::${n},`;
-const mapAssign = map(assign);
-const this_ = ['this: &Object'];
-const rustType = (n) => `pub type ${n} = nanocom::${n}<Interface>;`;
-const whereContent = (h) => (wh) => {
-    const w = 'where' in wh ? [
-        h,
-        `where`,
-        mapComma(wh.where),
-        '{'
-    ] : [`${h} {`];
-    const x = [
-        wh.content,
-        '}',
-    ];
-    return flat([w, x]);
-};
-const rustImpl = (i) => {
-    const p = 'param' in i ? `<${i.param}>` : '';
-    const header = `impl${p} ${i.trait} for ${i.type}`;
-    return whereContent(header)(i);
-};
-const comma = s => `${s},`;
-const mapComma = map(comma);
-const trait = (t) => {
-    const p = t.pub === true ? 'pub ' : '';
-    const h = `${p}trait ${t.type}`;
-    return whereContent(h)(t);
-};
-const traitImpl = (t) => {
-    const i = rustImpl({
-        param: 'T',
-        trait: t.type,
-        type: 'T',
-        where,
-        content: [],
-    });
-    return flat([trait({ ...t, where }), i]);
-};
-const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex'];
-/**
- * Generates Rust code for the given type library.
- *
- * @param library - The library of type definitions to generate Rust code for.
- * @returns A block of Rust code representing the library.
- */
-export const rust = (library) => {
-    const type = (p) => {
-        const f = (o) => (t) => {
-            if (typeof t === 'string') {
-                return t;
-            }
-            if (t.length === 2) {
-                return `*const ${f(ref)(t[1])}`;
-            }
-            const [id] = t;
-            const fullId = `${p}${id}`;
-            return 'interface' in library[id] ? o(fullId) : fullId;
-        };
-        return f;
-    };
-    const pf = (p) => (o) => ([name, t]) => `${name}: ${type(p)(o)(t)}`;
-    const param = pf(super_)(obj);
-    const mapParam = map(param);
-    const mapField = map(pf('')(ref));
-    const struct = fn(entries)
-        .then(mapField)
-        .then(rustStruct)
-        .result;
-    const func = (first) => (p) => {
-        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : '';
-        const params = commaJoin(flat([first, mapParam(paramList(p))]));
-        return `(${params})${resultStr}`;
-    };
-    const virtualFnType = (n) => (p) => `extern "system" fn${n}${func(this_)(p)}`;
-    const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`;
-    const mapVirtualFn = map(virtualFn);
-    const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`;
-    const traitFn = (m) => `${headerFn(m)};`;
-    const mapTraitFn = map(traitFn);
-    const implFn = (m) => {
-        const [n, p] = m;
-        return [
-            `${headerFn(m)} {`,
-            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
-            '}'
-        ];
-    };
-    const flatMapImplFn = flatMap(implFn);
-    const impl = ([n, p]) => {
-        const type = virtualFnType(` ${n}`)(p);
-        return [
-            `${type} {`,
-            [`unsafe { nanocom::CObject::from_object_unchecked(this) }.${n}(${call(p)})`],
-            '}'
-        ];
-    };
-    const flatMapImpl = flatMap(impl);
-    const interface_ = ({ interface: i, guid }) => (name) => {
-        const e = entries(i);
-        return [
-            `pub mod ${name} {`,
-            [
-                rustType('Object'),
-                rustType('Ref'),
-                rustType('Vmt'),
-            ],
-            rustStruct(mapVirtualFn(e))('Interface'),
-            rustImpl({
-                trait: 'nanocom::Interface',
-                type: 'Interface',
-                content: [`const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`]
-            }),
-            trait({ pub: true, type: 'Ex', content: mapTraitFn(e) }),
-            rustImpl({
-                trait: 'Ex',
-                type: 'Object',
-                content: flatMapImplFn(e)
-            }),
-            traitImpl({
-                pub: true,
-                type: 'ClassEx',
-                content: ['const VMT: Vmt = Vmt {',
-                    ['iunknown: nanocom::CObject::<Self>::IUNKNOWN,',
-                        'interface: Interface {',
-                        mapAssign(e),
-                        '},',
-                    ],
-                    '};'
-                ]
-            }),
-            traitImpl({
-                type: 'PrivateClassEx',
-                content: flatMapImpl(e)
-            }),
-            '}'
-        ];
-    };
-    const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name);
-    return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))]);
-};

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

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