functionalscript 0.8.2 → 0.9.2

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,25 @@
+import { fromIo } from "../io/module.f.js";
+import { compile } from "../djs/module.f.js";
+import { main as testMain } from "../dev/tf/module.f.js";
+import { main as casMain } from "../cas/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':
+            return fromIo(io)(casMain(rest));
+        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/fsc/module.f.js

@@ -26,7 +26,7 @@ const reduce = (a) => {
     return toArray(listReduce(merge)(empty)(a));
 };
 const codePointRange = fromRange(def);
-const range = fn(asciiRange).then(codePointRange).result;
+const range = fn(asciiRange).map(codePointRange).result;
 const rangeSet = (l) => (f) => {
     const codePointRange = fromRange(def);
     const g = r => codePointRange(asciiRange(r))(f);

package/io/module.d.ts

@@ -1,4 +1,8 @@
 import { type Io, type Run } from './module.f.ts';
+import type { NodeProgram } from '../types/effect/node/module.f.ts';
 export declare const io: Io;
 declare const runDefault: Run;
 export default runDefault;
+export type NodeRun = (p: NodeProgram) => Promise<number>;
+export declare const ioRun: (io: Io) => NodeRun;
+export declare const nodeRun: NodeRun;

package/io/module.f.d.ts

@@ -1,15 +1,12 @@
-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';
+import type { NodeEffect } from '../types/effect/node/module.f.ts';
+import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
  * @see https://nodejs.org/api/fs.html#class-fsdirent
  */
 export type Dirent = {
     readonly name: string;
+    readonly parentPath: string;
     readonly isDirectory: () => boolean;
     readonly isFile: () => boolean;
 };
@@ -20,21 +17,24 @@ export type RmOptions = {
 export type MakeDirectoryOptions = {
     readonly recursive?: boolean;
 };
+export type ReadDir = ((path: string, options: {
+    withFileTypes: true;
+}) => Promise<Dirent[]>) & ((path: string, options: {
+    recursive?: true;
+}) => Promise<readonly string[]>);
 /**
  * File system operations interface
  * @see https://nodejs.org/api/fs.html
  */
 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 readdir: (path: string, options: {
-            withFileTypes: true;
-        }) => Promise<Dirent[]>;
+        readonly readFile: (path: string) => Promise<Uint8Array>;
+        readonly writeFile: (path: string, data: Uint8Array) => Promise<void>;
+        readonly readdir: ReadDir;
         readonly rm: (path: string, options?: RmOptions) => Promise<void>;
         readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
         readonly copyFile: (src: string, dest: string) => Promise<void>;
@@ -104,3 +104,4 @@ export type Run = (f: App) => Promise<never>;
  * Handles errors by exiting with code 1
  */
 export declare const run: (io: Io) => Run;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }: Io) => <T>(effect: NodeEffect<T>) => Promise<T>;

package/io/module.f.js

@@ -1,3 +1,7 @@
+import { normalize } from "../path/module.f.js";
+import { asyncRun } from "../types/effect/module.js";
+import { error, ok } from "../types/result/module.f.js";
+import { fromVec, toVec } from "../types/uint8array/module.f.js";
 /**
  * Runs a function and exits the process with the returned code
  * Handles errors by exiting with code 1
@@ -14,3 +18,20 @@ export const run = (io) => {
     };
     return async (f) => io.process.exit(code(await io.asyncTryCatch(() => f(io))));
 };
+const tc = async (f) => {
+    try {
+        return ok(await f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, }) => asyncRun({
+    error: async (message) => error(message),
+    log: async (message) => log(message),
+    mkdir: param => tc(async () => { await mkdir(...param); }),
+    readFile: path => tc(async () => toVec(await readFile(path))),
+    readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
+        .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
+    writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+});

package/io/module.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { run } from "./module.f.js";
+import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from "node:process";
 import { concat } from "../path/module.f.js";
@@ -41,3 +41,9 @@ export const io = {
 };
 const runDefault = run(io);
 export default runDefault;
+export const ioRun = (io) => {
+    const r = fromIo(io);
+    const { argv } = io.process;
+    return p => r(p(argv));
+};
+export const nodeRun = ioRun(io);

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/json/module.f.js

@@ -25,9 +25,9 @@ export const serialize = sort => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         switch (typeof value) {

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.8.2",
+  "version": "0.9.2",
   "type": "module",
   "files": [
     "**/*.js",
@@ -9,21 +9,20 @@
   "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",
+    "website": "node --experimental-strip-types ./website/module.ts"
   },
   "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,3 +1,4 @@
 import type { Reduce, Unary } from "../types/function/operator/module.f.ts";
+export declare const parse: (path: string) => readonly string[];
 export declare const normalize: Unary<string, string>;
 export declare const concat: Reduce<string>;

package/path/module.f.js

@@ -1,4 +1,4 @@
-import { fold, last, take, length, concat as listConcat } from "../types/list/module.f.js";
+import { fold, last, take, length, concat as listConcat, toArray } from "../types/list/module.f.js";
 import { join } from "../types/string/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
 const foldNormalizeOp = input => state => {
@@ -21,9 +21,12 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
-export const normalize = path => {
+export const parse = (path) => {
     const split = path.replaceAll('\\', '/').split('/');
-    const foldResult = fold(foldNormalizeOp)([])(split);
+    return toArray(fold(foldNormalizeOp)([])(split));
+};
+export const normalize = path => {
+    const foldResult = parse(path);
     return join('/')(foldResult);
 };
 export const concat = a => b => {

package/text/utf16/module.f.js

@@ -332,7 +332,7 @@ export const stringToCodePointList = (input) => toCodePointList(stringToList(inp
  * ```
  */
 export const listToString = fn(map(String.fromCharCode))
-    .then(reduce(concat)(''))
+    .map(reduce(concat)(''))
     .result;
 /**
  * Converts a list of Unicode code points (CodePoint) to a string.