functionalscript 0.8.1 → 0.9.1

package/dev/version/module.f.js

@@ -1,13 +1,14 @@
+import { decodeUtf8, encodeUtf8 } from "../../types/uint8array/module.f.js";
 const { stringify, parse } = JSON;
 export const getVersion = fs => readJson(fs)('package').version;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = fs => name => parse(fs.readFileSync(jsonFile(name), 'utf8'));
+const readJson = fs => name => parse(decodeUtf8(fs.readFileSync(jsonFile(name))));
 export const updateVersion = ({ fs }) => {
     const f = (name) => {
-        return fs.writeFileSync(jsonFile(name), stringify({
+        return fs.writeFileSync(jsonFile(name), encodeUtf8(stringify({
             ...readJson(fs)(name),
             version: getVersion(fs)
-        }, null, 2));
+        }, null, 2)));
     };
     return [
         f('package'),

package/dev/version/test.f.js

@@ -1,3 +1,4 @@
+import { decodeUtf8, encodeUtf8 } from "../../types/uint8array/module.f.js";
 import * as _ from "./module.f.js";
 const version = '0.3.0';
 const x = {
@@ -76,8 +77,8 @@ const e = '{\n' +
 export default () => {
     const node = {
         fs: {
-            readFileSync: n => JSON.stringify(x[n]),
-            writeFileSync: (_, content) => content
+            readFileSync: n => encodeUtf8(JSON.stringify(x[n])),
+            writeFileSync: (_, content) => decodeUtf8(content)
         }
     };
     const [n, d] = _.updateVersion(node);

package/djs/module.f.d.ts

@@ -6,4 +6,4 @@ export type Object = {
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;
 export type Unknown = Primitive | Object | Array;
-export declare const compile: ({ console: { error }, fs, process: { argv } }: Io) => Promise<number>;
+export declare const compile: ({ console: { error }, fs }: Io) => (args: readonly string[]) => Promise<number>;

package/djs/module.f.js

@@ -1,8 +1,8 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-export const compile = ({ console: { error }, fs, process: { argv } }) => {
-    const args = argv.slice(2);
+import { encodeUtf8 } from "../types/uint8array/module.f.js";
+export const compile = ({ console: { error }, fs }) => (args) => {
     if (args.length < 2) {
         error('Error: Requires 2 or more arguments');
         return Promise.resolve(1);
@@ -14,11 +14,11 @@ export const compile = ({ console: { error }, fs, process: { argv } }) => {
         case 'ok': {
             if (outputFileName.endsWith('.json')) {
                 const output = stringifyAsTree(sort)(result[1]);
-                fs.writeFileSync(outputFileName, output);
+                fs.writeFileSync(outputFileName, encodeUtf8(output));
                 break;
             }
             const output = stringify(sort)(result[1]);
-            fs.writeFileSync(outputFileName, output);
+            fs.writeFileSync(outputFileName, encodeUtf8(output));
             break;
         }
         case 'error': {

package/djs/transpiler/module.f.js

@@ -8,6 +8,7 @@ import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";
 import { run } from "../ast/module.f.js";
+import { decodeUtf8 } from "../../types/uint8array/module.f.js";
 const mapDjs = context => path => {
     const res = at(path)(context.complete);
     if (res === null) {
@@ -30,11 +31,11 @@ const transpileWithImports = path => parseModuleResult => context => {
     return { ...context, error: parseModuleResult[1] };
 };
 const parseModule = path => context => {
-    const content = context.fs.readFileSync(path, 'utf8');
+    const content = context.fs.readFileSync(path);
     if (content === null) {
         return error({ message: 'file not found', metadata: null });
     }
-    const tokens = tokenize(stringToList(content))(path);
+    const tokens = tokenize(stringToList(decodeUtf8(content)))(path);
     return parseFromTokens(tokens);
 };
 const foldNextModuleOp = path => context => {

package/djs/transpiler/test.f.js

@@ -3,12 +3,13 @@ import { setReplace } from "../../types/ordered_map/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
 import { createVirtualIo } from "../../io/virtual/module.f.js";
+import { encodeUtf8 } from "../../types/uint8array/module.f.js";
 const virtualFs = map => {
     return createVirtualIo(map).fs;
 };
 export default {
     parse: () => {
-        const map = setReplace('a')('export default 1')(null);
+        const map = setReplace('a')(encodeUtf8('export default 1'))(null);
         const fs = virtualFs(map);
         const result = transpile(fs)('a');
         if (result[0] === 'error') {
@@ -20,8 +21,8 @@ export default {
         }
     },
     parseWithSubModule: () => {
-        const map = setReplace('a/b')('import c from "c"\nexport default c')(null);
-        const map2 = setReplace('a/c')('export default 2')(map);
+        const map = setReplace('a/b')(encodeUtf8('import c from "c"\nexport default c'))(null);
+        const map2 = setReplace('a/c')(encodeUtf8('export default 2'))(map);
         const fs = virtualFs(map2);
         const result = transpile(fs)('a/b');
         if (result[0] === 'error') {
@@ -33,10 +34,10 @@ export default {
         }
     },
     parseWithSubModules: () => {
-        const map = setReplace('a')('import b from "b"\nimport c from "c"\nexport default [b,c,b]')(null);
-        const map2 = setReplace('b')('import d from "d"\nexport default [0,d]')(map);
-        const map3 = setReplace('c')('import d from "d"\nexport default [1,d]')(map2);
-        const map4 = setReplace('d')('export default 2')(map3);
+        const map = setReplace('a')(encodeUtf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'))(null);
+        const map2 = setReplace('b')(encodeUtf8('import d from "d"\nexport default [0,d]'))(map);
+        const map3 = setReplace('c')(encodeUtf8('import d from "d"\nexport default [1,d]'))(map2);
+        const map4 = setReplace('d')(encodeUtf8('export default 2'))(map3);
         const fs = virtualFs(map4);
         const result = transpile(fs)('a');
         if (result[0] === 'error') {
@@ -48,7 +49,7 @@ export default {
         }
     },
     parseWithFileNotFoundError: () => {
-        const map = setReplace('a')('import b from "b"\nexport default b')(null);
+        const map = setReplace('a')(encodeUtf8('import b from "b"\nexport default b'))(null);
         const fs = virtualFs(map);
         const result = transpile(fs)('a');
         if (result[0] !== 'error') {
@@ -59,9 +60,9 @@ export default {
         }
     },
     parseWithCycleError: () => {
-        const map = setReplace('a')('import b from "b"\nimport c from "c"\nexport default [b,c,b]')(null);
-        const map2 = setReplace('b')('import c from "c"\nexport default c')(map);
-        const map3 = setReplace('c')('import b from "b"\nexport default b')(map2);
+        const map = setReplace('a')(encodeUtf8('import b from "b"\nimport c from "c"\nexport default [b,c,b]'))(null);
+        const map2 = setReplace('b')(encodeUtf8('import c from "c"\nexport default c'))(map);
+        const map3 = setReplace('c')(encodeUtf8('import b from "b"\nexport default b'))(map2);
         const fs = virtualFs(map3);
         const result = transpile(fs)('a');
         if (result[0] !== 'error') {

package/fjs/module.f.d.ts

@@ -0,0 +1,2 @@
+import type { Io } from '../io/module.f.ts';
+export declare const main: (io: Io) => Promise<number>;

package/fjs/module.f.js

@@ -0,0 +1,24 @@
+import { compile } from "../djs/module.f.js";
+import { main as testMain } from "../dev/tf/module.f.js";
+export const main = (io) => {
+    const { error } = io.console;
+    const [command, ...rest] = io.process.argv.slice(2);
+    switch (command) {
+        case 'test':
+        case 't':
+            return testMain(io);
+        case 'compile':
+        case 'c':
+            return compile(io)(rest);
+        case 'cas':
+        case 's':
+            error('cas command is not implemented yet');
+            return Promise.resolve(1);
+        case undefined:
+            error('Error: command is required');
+            return Promise.resolve(1);
+        default:
+            error(`Error: Unknown command "${command}"`);
+            return Promise.resolve(1);
+    }
+};

package/{dev/tf → fjs}/module.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 import { main } from "./module.f.js";
-import node from "../../io/module.js";
+import node from "../io/module.js";
 await node(main);

package/io/module.f.d.ts

@@ -1,9 +1,4 @@
 import type { Result } from '../types/result/module.f.ts';
-/**
- * Standard Node.js buffer encoding type
- * @see https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
- */
-export type BufferEncoding = 'utf8';
 /**
  * Represents a directory entry (file or directory) in the filesystem
  * @see https://nodejs.org/api/fs.html#class-fsdirent
@@ -26,12 +21,12 @@ export type MakeDirectoryOptions = {
  */
 export type Fs = {
     readonly writeSync: (fd: number, s: string) => void;
-    readonly writeFileSync: (file: string, data: string) => void;
-    readonly readFileSync: (path: string, options: BufferEncoding) => string | null;
+    readonly writeFileSync: (file: string, data: Uint8Array) => void;
+    readonly readFileSync: (path: string) => Uint8Array | null;
     readonly existsSync: (path: string) => boolean;
     readonly promises: {
-        readonly readFile: (path: string, options: BufferEncoding) => Promise<string>;
-        readonly writeFile: (path: string, data: string, options: BufferEncoding) => Promise<void>;
+        readonly readFile: (path: string) => Promise<Uint8Array>;
+        readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
         readonly readdir: (path: string, options: {
             withFileTypes: true;
         }) => Promise<Dirent[]>;

package/io/virtual/module.f.d.ts

@@ -1,3 +1,3 @@
 import type { Io } from '../module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-export declare const createVirtualIo: (files: OrderedMap<string>) => Io;
+export declare const createVirtualIo: (files: OrderedMap<Uint8Array>) => Io;

package/io/virtual/module.f.js

@@ -7,12 +7,12 @@ export const createVirtualIo = (files) => ({
     fs: {
         writeSync: (fd, s) => { },
         writeFileSync: (_file, _data) => { },
-        readFileSync: (path, _options) => { return at(path)(files); },
+        readFileSync: (path) => { return at(path)(files); },
         existsSync: (path) => { return at(path)(files) !== null; },
         promises: {
             readdir: (_path) => Promise.resolve([]),
-            readFile: (_path, _options) => Promise.resolve(''),
-            writeFile: (_path, _data, _options) => Promise.resolve(),
+            readFile: (_path) => Promise.resolve(new Uint8Array()),
+            writeFile: (_path, _data) => Promise.resolve(),
             rm: (_path, _options) => Promise.resolve(),
             mkdir: (_path, _options) => Promise.resolve(undefined),
             copyFile: (_src, _dest) => Promise.resolve(),

package/js/tokenizer/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type List } from '../../types/list/module.f.ts';
-import { type BigFloat } from '../../types/bigfloat/module.f.ts';
+import type { BigFloat } from '../../types/bigfloat/module.f.ts';
 export type StringToken = {
     readonly kind: 'string';
     readonly value: string;

package/js/tokenizer/module.f.js

@@ -3,7 +3,6 @@ import { merge, fromRange, get } from "../../types/range_map/module.f.js";
 import { empty, stateScan, flat, toArray, reduce as listReduce, scan, map as listMap } from "../../types/list/module.f.js";
 import { at, fromEntries } from "../../types/ordered_map/module.f.js";
 import { one } from "../../types/range/module.f.js";
-import {} from "../../types/bigfloat/module.f.js";
 import { range, 
 //
 backspace, ht, lf, ff, cr, 

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

@@ -1,5 +1,5 @@
 declare const _default: {
-    eq: {
+    eq: () => {
         nullish: () => void;
         boolean: {
             boolean: () => void;

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

@@ -1,121 +1,131 @@
-const e = (a) => (b) => {
-    if (a === b) { }
+const { is } = Object;
+const ois = (a) => (b) => {
+    if (is(a, b)) { }
     else {
-        throw [a, '===', b];
+        throw [a, 'is', b];
     }
 };
-const n = (a) => (b) => {
-    if (a !== b) { }
-    else {
-        throw [a, '!==', b];
-    }
-};
-const nan_res = (op) => (n) => {
+const { isNaN } = Number;
+const nanRes = (op) => (n) => {
     const result = op(n);
-    if (!Number.isNaN(result)) {
+    if (!isNaN(result)) {
         throw result;
     }
 };
 export default {
-    eq: {
-        nullish: () => {
-            e(null)(null);
-            e(undefined)(undefined);
-            n(null)(undefined);
-        },
-        boolean: {
-            boolean: () => {
-                e(true)(true);
-                e(false)(false);
-                n(true)(false);
-            },
-            nullish: () => {
-                n(false)(undefined);
-                n(false)(null);
+    eq: () => {
+        const e = (a) => (b) => {
+            if (a === b) { }
+            else {
+                throw [a, '===', b];
+            }
+        };
+        const n = (a) => (b) => {
+            if (a !== b) { }
+            else {
+                throw [a, '!==', b];
             }
-        },
-        number: {
-            number: () => {
-                e(2.3)(2.3);
-                n(2.3)(-5.4);
-                n(NaN)(NaN);
-                e(0)(-0);
-                if (!Object.is(-0, -0)) {
-                    throw -0;
+        };
+        return {
+            nullish: () => {
+                e(null)(null);
+                e(undefined)(undefined);
+                n(null)(undefined);
+            },
+            boolean: {
+                boolean: () => {
+                    e(true)(true);
+                    e(false)(false);
+                    n(true)(false);
+                },
+                nullish: () => {
+                    n(false)(undefined);
+                    n(false)(null);
                 }
-                if (Object.is(0, -0)) {
-                    throw -0;
+            },
+            number: {
+                number: () => {
+                    e(2.3)(2.3);
+                    n(2.3)(-5.4);
+                    n(NaN)(NaN);
+                    e(0)(-0);
+                    if (!is(-0, -0)) {
+                        throw -0;
+                    }
+                    if (is(0, -0)) {
+                        throw -0;
+                    }
+                    e(Infinity)(Infinity);
+                    e(-Infinity)(-Infinity);
+                    n(Infinity)(-Infinity);
+                },
+                nullish: () => {
+                    n(undefined)(NaN);
+                    n(undefined)(0);
                 }
-                e(Infinity)(Infinity);
-                e(-Infinity)(-Infinity);
-                n(Infinity)(-Infinity);
             },
-            nullish: () => {
-                n(undefined)(NaN);
-                n(undefined)(0);
-            }
-        },
-        string: {
-            string: () => {
-                e("hello")("hello");
-                n("hello")("world");
-            },
-            number: () => {
-                n(0)("0");
-            }
-        },
-        bigint: {
-            bigint: () => {
-                e(12n)(12n);
-                n(12n)(-12n);
-                n(12n)(13n);
-            }
-        },
-        array: {
-            array: () => {
-                const a = [];
-                e(a)(a);
-                n([])([]);
-                const a0 = ['0'];
-                e(a0)(a0);
-            }
-        },
-        object: {
-            object: () => {
-                const o = { '0': '0' };
-                e(o)(o);
-                n(o)({ '0': '0' });
+            string: {
+                string: () => {
+                    e("hello")("hello");
+                    n("hello")("world");
+                },
+                number: () => {
+                    n(0)("0");
+                }
+            },
+            bigint: {
+                bigint: () => {
+                    e(12n)(12n);
+                    n(12n)(-12n);
+                    n(12n)(13n);
+                }
+            },
+            array: {
+                array: () => {
+                    const a = [];
+                    e(a)(a);
+                    n([])([]);
+                    const a0 = ['0'];
+                    e(a0)(a0);
+                }
+            },
+            object: {
+                object: () => {
+                    const o = { '0': '0' };
+                    e(o)(o);
+                    n(o)({ '0': '0' });
+                }
             }
-        }
+        };
     },
     unary_plus: () => {
         const op = (n) => +n;
-        const nan = nan_res(op);
+        const nan = nanRes(op);
         return {
-            null: () => e(op(null))(0),
+            null: () => ois(op(null))(0),
             undefined: () => nan(undefined),
             boolean: {
-                false: () => e(op(false))(0),
-                true: () => e(op(true))(1)
+                false: () => ois(op(false))(0),
+                true: () => ois(op(true))(1)
             },
             number: {
-                zero: () => e(op(0))(0),
-                positive: () => e(op(2.3))(2.3),
-                negative: () => e(op(-2.3))(-2.3)
+                zero: () => ois(op(0))(0),
+                positive: () => ois(op(2.3))(2.3),
+                negative: () => ois(op(-2.3))(-2.3)
             },
             string: {
-                empty: () => e(op(""))(0),
-                zero: () => e(op("0"))(0),
-                positive: () => e(op("2.3"))(2.3),
+                empty: () => ois(op(""))(0),
+                zero: () => ois(op("0"))(0),
+                positive: () => ois(op("2.3"))(2.3),
                 nan: () => nan("a")
             },
             bigint: {
                 throw: () => op(0n),
             },
             array: {
-                empty: () => e(op([]))(0),
-                single_number: () => e(op([2.3]))(2.3),
-                single_string: () => e(op(["-2.3"]))(-2.3),
+                empty: () => ois(op([]))(0),
+                single_number: () => ois(op([2.3]))(2.3),
+                single_string: () => ois(op(["-2.3"]))(-2.3),
                 multiple: () => nan([null, null])
             },
             object: {
@@ -127,33 +137,33 @@ export default {
     },
     unary_minus: () => {
         const op = (n) => -n;
-        const nan = nan_res(op);
+        const nan = nanRes(op);
         return {
-            null: () => e(op(null))(0),
+            null: () => ois(op(null))(-0),
             undefined: () => nan(undefined),
             boolean: {
-                false: () => e(op(false))(0),
-                true: () => e(op(true))(-1)
+                false: () => ois(op(false))(-0),
+                true: () => ois(op(true))(-1)
             },
             number: {
-                zero: () => e(op(0))(0),
-                positive: () => e(op(2.3))(-2.3),
-                negative: () => e(op(-2.3))(2.3)
+                zero: () => ois(op(0))(-0),
+                positive: () => ois(op(2.3))(-2.3),
+                negative: () => ois(op(-2.3))(2.3)
             },
             string: {
-                empty: () => e(op(""))(0),
-                zero: () => e(op("0"))(0),
-                positive: () => e(op("2.3"))(-2.3),
+                empty: () => ois(op(""))(-0),
+                zero: () => ois(op("0"))(-0),
+                positive: () => ois(op("2.3"))(-2.3),
                 nan: () => nan("a")
             },
             bigint: {
-                positive: () => e(op(1n))(-1n),
-                negative: () => e(op(-1n))(1n),
+                positive: () => ois(op(1n))(-1n),
+                negative: () => ois(op(-1n))(1n),
             },
             array: {
-                empty: () => e(op([]))(0),
-                single_number: () => e(op([2.3]))(-2.3),
-                single_string: () => e(op(["-2.3"]))(2.3),
+                empty: () => ois(op([]))(-0),
+                single_number: () => ois(op([2.3]))(-2.3),
+                single_string: () => ois(op(["-2.3"]))(2.3),
                 multiple: () => nan([null, null])
             },
             object: {

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

@@ -1,4 +1,4 @@
-const stringCoercion = (a) => a + '';
+const stringCoercion = String;
 export default {
     stringCoercion: {
         number: () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "type": "module",
   "files": [
     "**/*.js",
@@ -9,21 +9,19 @@
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
     "prepack": "tsc --NoEmit false",
-    "git-clean": "git clean -xf",
     "test20": "npm run prepack && node --test",
     "test": "tsc && node --test --experimental-strip-types --experimental-test-coverage --test-coverage-include=**/module.f.ts",
     "index": "node ./dev/index/module.ts",
-    "fsc": "node ./fsc/module.ts",
-    "fst": "node ./dev/tf/module.ts",
+    "fst": "node ./fjs/module.ts t",
+    "fjs": "node ./fjs/module.ts",
     "ci-update": "node ./ci/module.ts",
-    "update": "npm install && npm run index && npm run ci-update"
+    "update": "git clean -fdx && npm install && npm run index && npm run ci-update"
   },
   "engines": {
     "node": ">=20"
   },
   "bin": {
-    "fsc": "fsc/module.js",
-    "fst": "dev/tf/module.js"
+    "fjs": "fjs/module.js"
   },
   "repository": {
     "type": "git",

package/path/module.f.d.ts

@@ -1,2 +1,3 @@
-export declare const normalize: (path: string) => string;
-export declare const concat: (a: string) => (b: string) => string;
+import type { Reduce, Unary } from "../types/function/operator/module.f.ts";
+export declare const normalize: Unary<string, string>;
+export declare const concat: Reduce<string>;

package/types/btree/find/module.f.d.ts

@@ -2,13 +2,13 @@ import type { Leaf1, Leaf2, Branch3, Branch5, TNode } from '../types/module.f.ts
 import type { List } from '../../list/module.f.ts';
 import { type Compare } from '../../function/compare/module.f.ts';
 import type { Index3, Index5 } from "../../array/module.f.ts";
-type FirstLeaf1<T> = readonly [Index3, Leaf1<T>];
-type FirstBranch3<T> = readonly [1, Branch3<T>];
-type FirstLeaf2<T> = readonly [Index5, Leaf2<T>];
-type FirstBranch5<T> = readonly [1 | 3, Branch5<T>];
-type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
-type PathItem3<T> = readonly [0 | 2, Branch3<T>];
-type PathItem5<T> = readonly [0 | 2 | 4, Branch5<T>];
+export type FirstLeaf1<T> = readonly [Index3, Leaf1<T>];
+export type FirstBranch3<T> = readonly [1, Branch3<T>];
+export type FirstLeaf2<T> = readonly [Index5, Leaf2<T>];
+export type FirstBranch5<T> = readonly [1 | 3, Branch5<T>];
+export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
+export type PathItem3<T> = readonly [0 | 2, Branch3<T>];
+export type PathItem5<T> = readonly [0 | 2 | 4, Branch5<T>];
 export type PathItem<T> = PathItem3<T> | PathItem5<T>;
 export type Path<T> = List<PathItem<T>>;
 export type Result<T> = {
@@ -18,4 +18,3 @@ export type Result<T> = {
 export declare const find: <T>(c: Compare<T>) => (node: TNode<T>) => Result<T>;
 export declare const isFound: <T>([i]: First<T>) => boolean;
 export declare const value: <T>([i, r]: First<T>) => T | null;
-export {};