functionalscript 0.1.593 → 0.1.596

package/.github/workflows/npm-publish.yml

@@ -24,9 +24,10 @@ jobs:
       - uses: denoland/setup-deno@v1
         with:
           deno-version: 2
-      # - run: npm ci
+      - run: npm ci
       - run: npm run version
       - run: npm run index
+      - run: npm run tscp
       - run: npm publish
         env:
           NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/README.md

@@ -1,6 +1,7 @@
 # FunctionalScript
 
 [![NPM Version](https://img.shields.io/npm/v/functionalscript)](https://www.npmjs.com/package/functionalscript)
+[![JSR Version](https://img.shields.io/jsr/v/%40functionalscript/functionalscript)](https://jsr.io/@functionalscript/functionalscript)
 
 FunctionalScript is a purely functional programming language and a strict subset of
 [ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by

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

@@ -0,0 +1,8 @@
+declare namespace _default {
+    export { cpp };
+}
+export default _default;
+/** @type {(name: string) => (lib: typesT.Library) => textT.Block} */
+declare const cpp: (name: string) => (lib: typesT.Library) => textT.Block;
+import * as typesT from '../types/module.f.mjs';
+import * as textT from '../../text/module.f.mjs';

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

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

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

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

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

@@ -0,0 +1,8 @@
+declare namespace _default {
+    export { cs };
+}
+export default _default;
+/** @type {(name: string) => (library: typesT.Library) => textT.Block} */
+declare const cs: (name: string) => (library: typesT.Library) => textT.Block;
+import * as typesT from '../types/module.f.mjs';
+import * as textT from '../../text/module.f.mjs';

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

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

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

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

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

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { rust };
+}
+export default _default;
+export type OptionalProperty<T> = T | {};
+export type Where = {
+    readonly where: readonly string[];
+};
+export type WhereContent = OptionalProperty<Where> & {
+    readonly content: textT.Block;
+};
+export type Impl = {
+    readonly param?: string;
+    readonly trait: string;
+    readonly type: string;
+    readonly where?: readonly string[];
+    readonly content: textT.Block;
+};
+export type Trait = {
+    readonly pub?: true;
+    readonly type: string;
+    readonly where?: readonly string[];
+    readonly content: textT.Block;
+};
+/** @type {(library: typesT.Library) => textT.Block} */
+declare const rust: (library: typesT.Library) => textT.Block;
+import * as textT from '../../text/module.f.mjs';
+import * as typesT from '../types/module.f.mjs';

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

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

package/com/rust/testlib.f.d.mts

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

package/com/test/build.d.mts

@@ -0,0 +1 @@
+export {};

package/com/test/build.f.d.mts

@@ -0,0 +1,26 @@
+declare namespace _default {
+    export { cpp };
+    export { cs };
+    export { rust };
+}
+export default _default;
+export type Platform = "aix" | "android" | "darwin" | "freebsd" | "haiku" | "linux" | "openbsd" | "sunos" | "win32" | "cygwin" | "netbsd";
+export type NodeJs = {
+    readonly dirname: string;
+    readonly platform: Platform;
+};
+export type Output = {
+    readonly file: {
+        readonly name: string;
+        readonly content: string;
+    };
+    readonly line: List.List<List.List<string>>;
+};
+export type Func = (nodejs: NodeJs) => Output;
+/** @type {Func} */
+declare const cpp: Func;
+/** @type {Func} */
+declare const cs: Func;
+/** @type {Func} */
+declare const rust: Func;
+import * as List from '../../types/list/module.f.mjs';

package/com/types/module.f.d.mts

@@ -0,0 +1,28 @@
+declare namespace _default {
+    export { paramList };
+    export { result };
+}
+export default _default;
+export type Library = { readonly [k in string]: Definition; };
+export type Definition = Struct | Interface;
+export type Struct = {
+    readonly struct: FieldArray;
+};
+export type FieldArray = { readonly [k in string]: Type; };
+export type Field = O.Entry<Type>;
+export type Interface = {
+    readonly interface: MethodArray;
+    readonly guid: string;
+};
+export type MethodArray = { readonly [k in string]: FieldArray; };
+export type Method = O.Entry<FieldArray>;
+export type Type = BaseType | Id | Pointer;
+export type Id = readonly [string];
+export type BaseType = "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "u64" | "i64" | "usize" | "isize" | "f32" | "f64" | "bool";
+export type Pointer = readonly ["*", Type];
+/** @type {(fa: FieldArray) => List.List<Field> } */
+declare const paramList: (fa: FieldArray) => List.List<Field>;
+/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
+declare const result: <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T;
+import * as O from '../../types/object/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/com/types/testlib.f.d.mts

@@ -0,0 +1,44 @@
+declare const _default: {
+    Slice: {
+        struct: {
+            Start: ["*", "u8"];
+            Size: "usize";
+        };
+    };
+    ManagedStruct: {
+        struct: {
+            M: ["IMy"];
+        };
+    };
+    IMy: {
+        guid: string;
+        interface: {
+            GetSlice: {
+                _: ["Slice"];
+            };
+            SetSlice: {
+                slice: ["Slice"];
+            };
+            GetUnsafe: {
+                _: ["*", "bool"];
+            };
+            SetUnsafe: {
+                p: ["*", ["Slice"]];
+                size: "u32";
+            };
+            Some: {
+                p: ["IMy"];
+                _: "bool";
+            };
+            GetIMy: {
+                a: "u16";
+                b: "i16";
+                _: ["IMy"];
+            };
+            SetManagedStruct: {
+                a: ["ManagedStruct"];
+            };
+        };
+    };
+};
+export default _default;

package/commonjs/build/module.f.d.mts

@@ -0,0 +1,24 @@
+declare namespace _default {
+    export { getOrBuild };
+}
+export default _default;
+export type Config<M> = {
+    readonly packageGet: packageT.Get;
+    readonly moduleMapInterface: moduleT.MapInterface<M>;
+    readonly moduleId: moduleT.Id;
+    readonly moduleMap: M;
+};
+export type Result<M> = readonly [moduleT.State, M];
+/**
+ * @type {(compile: function_.Compile) =>
+ *  (packageGet: packageT.Get) =>
+ *  <M>(moduleMapInterface: moduleT.MapInterface<M>) =>
+ *  (moduleId: moduleT.Id) =>
+ *  (moduleMap: M) =>
+ *  Result<M>
+ * }
+ */
+declare const getOrBuild: (compile: function_.Compile) => (packageGet: packageT.Get) => <M>(moduleMapInterface: moduleT.MapInterface<M>) => (moduleId: moduleT.Id) => (moduleMap: M) => Result<M>;
+import * as packageT from '../package/module.f.mjs';
+import * as moduleT from '../module/module.f.mjs';
+import * as function_ from '../module/function/module.f.mjs';

package/commonjs/build/test.f.d.mts

@@ -0,0 +1,3 @@
+declare function _default(): void;
+export default _default;
+export type StringMap = { readonly [k in string]: string; };

package/commonjs/module/function/module.f.d.mts

@@ -0,0 +1,7 @@
+declare const _default: {};
+export default _default;
+export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>;
+export type Result<M> = readonly [Result.Result<unknown, unknown>, M];
+export type Require<M> = (path: string) => (prior: M) => Result<M>;
+export type Compile = (source: string) => Result.Result<Function_, unknown>;
+import * as Result from '../../../types/result/module.f.mjs';

package/commonjs/module/module.f.d.mts

@@ -0,0 +1,57 @@
+declare namespace _default {
+    export { dir };
+    export { idToString };
+}
+export default _default;
+export type MapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => State | null;
+    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M;
+};
+export type State = readonly ["ok", Module] | readonly ["error", Error];
+export type Module = {
+    readonly exports: unknown;
+    readonly requireMap: O.Map<string>;
+};
+export type Error = ["file not found"] | ["compilation error", unknown] | ["runtime error", unknown] | ["circular reference"];
+export type Id = {
+    readonly package: string;
+    readonly path: readonly string[];
+};
+/**
+ * @template M
+ * @typedef {{
+ *  readonly at: (moduleId: string) => (moduleMap: M) => State | null
+ *  readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+ * }} MapInterface
+ */
+/**
+ * @typedef {|
+ *  readonly['ok', Module] |
+ *  readonly['error', Error]
+ * } State
+ */
+/**
+ * @typedef {{
+ *  readonly exports: unknown
+ *  readonly requireMap: O.Map<string>
+ * }} Module
+ */
+/**
+ * @typedef {|
+ *  ['file not found'] |
+ *  ['compilation error', unknown] |
+ *  ['runtime error', unknown] |
+ *  ['circular reference']
+ * } Error
+ */
+/**
+ * @typedef {{
+ *  readonly package: string
+ *  readonly path: readonly string[]
+ * }} Id
+ */
+/** @type {(id: Id) => Id | null} */
+declare const dir: (id: Id) => Id | null;
+/** @type {(id: Id) => string} */
+declare const idToString: (id: Id) => string;
+import * as O from '../../types/object/module.f.mjs';

package/commonjs/module.d.mts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export { compile };
+}
+export default _default;
+/** @type {ModuleFunction.Compile} */
+declare const compile: ModuleFunction.Compile;
+import * as ModuleFunction from './module/function/module.f.mjs';

package/commonjs/module.f.d.mts

@@ -0,0 +1,4 @@
+declare const _default: {};
+export default _default;
+export type PackageMap = (packageName: string) => PackageMap | Package | null;
+export type Package = readonly [string, PackageMap, (fileName: string) => string | null];

package/commonjs/package/dependencies/module.f.d.mts

@@ -0,0 +1,10 @@
+declare namespace _default {
+    export { isDependenciesJson };
+}
+export default _default;
+export type DependencyJson = readonly [string, string];
+export type DependencyMapJson = { readonly [k in string]: string; };
+export type DependenciesJson = DependencyMapJson | null;
+/** @type {(j: jsonT.Unknown) => j is DependenciesJson} */
+declare const isDependenciesJson: (j: jsonT.Unknown) => j is DependenciesJson;
+import * as jsonT from '../../../json/module.f.mjs';

package/commonjs/package/dependencies/test.f.d.mts

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

package/commonjs/package/module.f.d.mts

@@ -0,0 +1,27 @@
+declare namespace _default {
+    export { dependencies };
+    export { isPackageJson };
+}
+export default _default;
+export type PackageJson = {
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies?: dependenciesT.DependenciesJson;
+};
+export type Package = {
+    readonly dependency: (localPackageId: string) => string | null;
+    readonly file: (localFileId: string) => string | null;
+};
+export type Get = (packageId: string) => Package | null;
+import dependencies from './dependencies/module.f.mjs';
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly version: string
+ *  readonly dependencies?: dependenciesT.DependenciesJson
+ * }} PackageJson
+ */
+/** @type {(j: jsonT.Unknown) => j is PackageJson} */
+declare const isPackageJson: (j: jsonT.Unknown) => j is PackageJson;
+import * as dependenciesT from './dependencies/module.f.mjs';
+import * as jsonT from '../../json/module.f.mjs';

package/commonjs/package/test.f.d.mts

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

package/commonjs/path/module.f.d.mts

@@ -0,0 +1,67 @@
+declare namespace _default {
+    export { parseLocal };
+    export { parseGlobal };
+    export { parse };
+    export { parseAndFind };
+}
+export default _default;
+export type Items = readonly string[];
+export type LocalPath = {
+    readonly external: boolean;
+    readonly dir: boolean;
+    readonly items: Items;
+};
+export type OptionList = readonly [List.List<string>] | null;
+export type IdPath = readonly [string, List.List<string>];
+export type Path = {
+    readonly package: string;
+    readonly items: Items;
+    readonly dir: boolean;
+};
+export type FoundResult = {
+    readonly id: moduleT.Id;
+    readonly source: string;
+};
+export type Result = FoundResult | null;
+/** @type {(local: string) => (path: string) => LocalPath|null} */
+declare const parseLocal: (local: string) => (path: string) => LocalPath | null;
+/**
+ * @typedef {{
+ *  readonly package: string,
+ *  readonly items: Items,
+ *  readonly dir: boolean,
+ * }} Path
+ */
+/**
+ * @type {(d: (local: string) => string|null) =>
+ *  (dir: boolean) =>
+ *  (items: List.List<string>) =>
+ *  Path|null}
+ */
+declare const parseGlobal: (d: (local: string) => string | null) => (dir: boolean) => (items: List.List<string>) => Path | null;
+/**
+ * @type {(packageId: string) =>
+ *  (dependencies: (local: string) => string|null) =>
+ *  (local: string) =>
+ *  (path: string) =>
+ *  Path|null }
+ */
+declare const parse: (packageId: string) => (dependencies: (local: string) => string | null) => (local: string) => (path: string) => Path | null;
+/**
+ * @typedef {{
+ *  readonly id: moduleT.Id
+ *  readonly source: string
+ * }} FoundResult
+ */
+/** @typedef {FoundResult| null} Result */
+/**
+ * @type {(packageGet: packageT.Get) =>
+ *  (moduleId: moduleT.Id) =>
+ *  (path: string) =>
+ *  Result
+ * }
+ */
+declare const parseAndFind: (packageGet: packageT.Get) => (moduleId: moduleT.Id) => (path: string) => Result;
+import * as List from '../../types/list/module.f.mjs';
+import * as moduleT from '../module/module.f.mjs';
+import * as packageT from '../package/module.f.mjs';

package/commonjs/path/test.f.d.mts

@@ -0,0 +1,25 @@
+declare const _default: {
+    0: () => void;
+    1: () => void;
+    2: () => void;
+    3: () => void;
+    4: () => void;
+    5: () => void;
+    6: () => void;
+    7: () => void;
+    8: {
+        0: () => void;
+        1: () => void;
+        2: () => void;
+        3: () => void;
+        4: () => void;
+        5: () => void;
+        6: () => void;
+        7: () => void;
+    };
+    9: () => void;
+    10: () => void;
+    11: () => void;
+    12: () => void;
+};
+export default _default;

package/commonjs/test.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    function ok(): void;
+    function compilationError(): void;
+    function compilationErrorStrict(): void;
+    function runtimeError(): void;
+    function test(): void;
+}
+export default _default;

package/dev/index.d.mts

@@ -0,0 +1 @@
+export {};

package/dev/module.d.mts

@@ -0,0 +1,26 @@
+/** @type {(code: number) => never} */
+export const exit: (code: number) => never;
+/** @type {(v: string) => string|undefined} */
+export const env: (v: string) => string | undefined;
+export function loadModuleMap(): Promise<ModuleMap>;
+export function index(): Promise<void>;
+export type Options = {
+    readonly withFileTypes: true;
+};
+export type Dirent = {
+    readonly name: string;
+    readonly isDirectory: () => boolean;
+};
+export type FsPromises = {
+    readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>;
+    readonly readFile: (path: string, options: "utf8") => Promise<string>;
+};
+export type Module = {
+    readonly default?: unknown;
+};
+export type Require = (name: string) => unknown;
+export type UnknownMap = { readonly [k in string]: unknown; };
+export type Entry<T> = readonly [string, T];
+export type MutableModuleMap = { [k in string]: Module; };
+export type ModuleMap = { readonly [k in string]: Module; };
+export type FolderMap = { readonly [k in string]: string | FolderMap; };

package/dev/module.f.d.mts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function todo(): never;
+}
+export default _default;

package/dev/test/module.f.d.mts

@@ -0,0 +1,26 @@
+export default main;
+export type DependencyMap = { readonly [k in string]?: Module; };
+export type Module = {
+    readonly default?: unknown;
+};
+export type ModuleMap = { readonly [k in string]: Module; };
+export type Log<T> = (v: string) => (state: T) => T;
+export type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
+export type Input<T> = {
+    readonly moduleMap: ModuleMap;
+    readonly log: Log<T>;
+    readonly error: Log<T>;
+    readonly measure: Measure<T>;
+    readonly state: T;
+    readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
+    readonly env: (n: string) => string | undefined;
+};
+export type TestState = {
+    readonly time: number;
+    readonly pass: number;
+    readonly fail: number;
+};
+export type FullState<T> = readonly [TestState, T];
+/** @type {<T>(input: Input<T>) => readonly[number, T]} */
+declare const main: <T>(input: Input<T>) => readonly [number, T];
+import * as Result from '../../types/result/module.f.mjs';

package/dev/test.d.mts

@@ -0,0 +1,3 @@
+export type Ok<T> = readonly ["ok", T];
+export type Error<E> = readonly ["error", E];
+export type Result<T, E> = Ok<T> | Error<E>;

package/dev/test.f.d.mts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    function ctor(): void;
+    function ctorEmpty(): void;
+    function ctorUndefined(): void;
+    function number(): void;
+    function properties(): void;
+    function getOwnPropertyDescriptor(): void;
+}
+export default _default;

package/djs/module.f.d.mts

@@ -0,0 +1,25 @@
+declare namespace _default {
+    export { stringify };
+    export { serialize };
+}
+export default _default;
+export type Object = { readonly [k in string]: Unknown; };
+export type Array = readonly Unknown[];
+export type Unknown = Object | boolean | string | number | null | Array | bigint;
+export type Entry = O.Entry<Unknown>;
+export type Entries = (List.List<Entry>);
+export type MapEntries = (entries: Entries) => Entries;
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ *
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
+ */
+declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+/** @typedef {O.Entry<Unknown>} Entry*/
+/** @typedef {(List.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
+declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List.List<string>;
+import * as O from '../types/object/module.f.mjs';
+import * as List from '../types/list/module.f.mjs';

package/djs/parser/module.f.d.mts

@@ -0,0 +1,40 @@
+declare namespace _default {
+    export { parse };
+}
+export default _default;
+export type JsonObject = {
+    readonly kind: "object";
+    readonly values: Map.Map<Djs.Unknown>;
+    readonly key: string;
+};
+export type JsonArray = {
+    readonly kind: "array";
+    readonly values: List.List<Djs.Unknown>;
+};
+export type JsonStackElement = JsonObject | JsonArray;
+export type JsonStack = List.List<JsonStackElement>;
+export type StateModule = {
+    readonly status: "module";
+    readonly stage: "module" | "." | "exports" | "=";
+};
+export type StateParse = {
+    readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
+    readonly top: JsonStackElement | null;
+    readonly stack: JsonStack;
+};
+export type StateResult = {
+    readonly status: "result";
+    readonly value: Djs.Unknown;
+};
+export type StateError = {
+    readonly status: "error";
+    readonly message: string;
+};
+export type DjsState = StateModule | StateParse | StateResult | StateError;
+/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>} */
+declare const parse: (tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>;
+import * as Map from '../../types/map/module.f.mjs';
+import * as Djs from '../module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';
+import * as tokenizerT from '../tokenizer/module.f.mjs';
+import * as Result from '../../types/result/module.f.mjs';

package/djs/parser/test.f.d.mts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    let valid: (() => void)[];
+    let invalid: (() => void)[];
+    let validWhiteSpaces: (() => void)[];
+    let validModule: (() => void)[];
+    let invalidModule: (() => void)[];
+}
+export default _default;

package/djs/test.f.d.mts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    let stringify: ({
+        sort: () => void;
+        identity: () => void;
+        stringify?: undefined;
+    } | {
+        stringify: () => void;
+        sort?: undefined;
+        identity?: undefined;
+    })[];
+}
+export default _default;

package/djs/tokenizer/module.f.d.mts

@@ -0,0 +1,17 @@
+declare namespace _default {
+    export { tokenize };
+}
+export default _default;
+export type DjsToken = {
+    readonly kind: "true" | "false" | "null";
+} | {
+    readonly kind: "{" | "}" | ":" | "," | "[" | "]" | "." | "=";
+} | jsTokenizerT.StringToken | jsTokenizerT.NumberToken | jsTokenizerT.ErrorToken | jsTokenizerT.IdToken | jsTokenizerT.BigIntToken | jsTokenizerT.WhitespaceToken;
+export type ScanState = {
+    readonly kind: "def" | "-";
+};
+export type ScanInput = jsTokenizerT.JsToken | null;
+/** @type {(input: List.List<number>) => List.List<DjsToken>} */
+declare const tokenize: (input: List.List<number>) => List.List<DjsToken>;
+import * as jsTokenizerT from '../../js/tokenizer/module.f.mjs';
+import * as List from '../../types/list/module.f.mjs';

package/djs/tokenizer/test.f.d.mts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    let djs: (() => void)[];
+    let id: (() => void)[];
+    let keywords: (() => void)[];
+}
+export default _default;