functionalscript 0.3.4 → 0.3.6

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

@@ -0,0 +1,84 @@
+const e = a => b => {
+    if (a === b) { }
+    else {
+        throw [a, '===', b];
+    }
+};
+const n = a => b => {
+    if (a !== b) { }
+    else {
+        throw [a, '!==', b];
+    }
+};
+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);
+            }
+        },
+        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;
+                }
+                if (Object.is(0, -0)) {
+                    throw -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' });
+            }
+        }
+    }
+};

package/nodejs/version/module.f.d.ts

@@ -0,0 +1,11 @@
+export type Buffer = {};
+type Fs<T> = {
+    readonly readFileSync: (name: string) => Buffer;
+    readonly writeFileSync: (name: string, content: string) => T;
+};
+export type Node<T> = {
+    readonly fs: Fs<T>;
+};
+export declare const getVersion: <T>(fs: Fs<T>) => string;
+export declare const updateVersion: <T>(node: Node<T>) => readonly [T, T];
+export {};

package/nodejs/version/module.f.js

@@ -0,0 +1,16 @@
+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)).toString());
+export const updateVersion = ({ fs }) => {
+    const f = (name) => {
+        return fs.writeFileSync(jsonFile(name), stringify({
+            ...readJson(fs)(name),
+            version: getVersion(fs)
+        }, null, 2));
+    };
+    return [
+        f('package'),
+        f('deno')
+    ];
+};

package/nodejs/version/test.f.d.ts

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

package/nodejs/version/{test.f.ts → test.f.js}

@@ -1,10 +1,6 @@
-import * as _ from './module.f.ts'
-
-const version = '0.3.0'
-
-const x
-    : { readonly[k in string]: unknown }
-    = {
+import * as _ from "./module.f.js";
+const version = '0.3.0';
+const x = {
     'package.json': {
         "name": "functionalscript",
         version,
@@ -41,8 +37,7 @@ const x
         }
     },
     "deno.json": {}
-}
-
+};
 const e = '{\n' +
     '  "name": "functionalscript",\n' +
     `  "version": "${version}",\n` +
@@ -77,23 +72,19 @@ const e = '{\n' +
     '    "@types/node": "^18.6.2",\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
-    '}'
-
-const buffer
-    : (s: string) => _.Buffer
-    = s => ({
+    '}';
+const buffer = s => ({
     toString: () => s
-})
-
+});
 export default () => {
-    const node
-        : _.Node<string>
-        = {
+    const node = {
         fs: {
             readFileSync: n => buffer(JSON.stringify(x[n])),
             writeFileSync: (_, content) => content
         }
+    };
+    const [n, d] = _.updateVersion(node);
+    if (n !== e) {
+        throw [n, e];
     }
-    const [n, d] = _.updateVersion(node)
-    if (n !== e) { throw [n, e] }
-}
+};

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "functionalscript",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "type": "module",
+  "files": [
+    "**/*.f.d.ts",
+    "**/*.f.js"
+  ],
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
-    "tscp": "tsc --NoEmit false --emitDeclarationOnly true",
-    "tsct": "tsc --NoEmit false --checkJs false",
-    "prepack": "npm run tscp && npm run tsct",
+    "tsc-emit": "tsc --NoEmit false",
+    "prepack": "npm run tsc-emit",
     "test20": "npm run prepack && node --trace-uncaught ./dev/test.js",
     "test": "tsc && node --experimental-strip-types --trace-uncaught ./dev/test.ts",
     "comtest": "node --experimental-strip-types ./com/test/build.ts",
     "index": "node --experimental-strip-types ./dev/index.ts",
-    "version": "node --experimental-strip-types ./nodejs/version/main.ts"
+    "version": "node --experimental-strip-types ./nodejs/version/main.ts",
+    "fsc": "node --experimental-strip-types ./main.ts"
   },
   "repository": {
     "type": "git",

package/text/ascii/module.f.d.ts

@@ -0,0 +1,129 @@
+import { type Range } from '../../types/range/module.f.ts';
+export declare const one: (s: string) => number;
+export declare const range: (s: string) => Range;
+/** 0x08 */
+export declare const backspace: number;
+/** 0x09 */
+export declare const ht: number;
+/** 0x0A */
+export declare const lf: number;
+/** 0x0C */
+export declare const ff: number;
+/** 0x0D */
+export declare const cr: number;
+/** 0x20 */
+export declare const space: number;
+/** 0x21 */
+export declare const exclamationMark: number;
+/** 0x22 */
+export declare const quotationMark: number;
+/** 0x23 */
+export declare const numberSign: number;
+/** 0x24 */
+export declare const dollarSign: number;
+/** 0x25 */
+export declare const percentSign: number;
+/** 0x26 */
+export declare const ampersand: number;
+/** 0x27 */
+export declare const apostrophe: number;
+/** 0x28 */
+export declare const leftParenthesis: number;
+/** 0x29 */
+export declare const rightParenthesis: number;
+/** 0x2A */
+export declare const asterisk: number;
+/** 0x2B */
+export declare const plusSign: number;
+/** 0x2C */
+export declare const comma: number;
+/** 0x2D */
+export declare const hyphenMinus: number;
+/** 0x2E */
+export declare const fullStop: number;
+/** 0x2F */
+export declare const solidus: number;
+/** 0x30..0x39 */
+export declare const digitRange: Range;
+/** 0x30 */
+export declare const digit0: number;
+/** 0x31 */
+export declare const digit1: number;
+/** 0x32 */
+export declare const digit2: number;
+/** 0x33 */
+export declare const digit3: number;
+/** 0x34 */
+export declare const digit4: number;
+/** 0x35 */
+export declare const digit5: number;
+/** 0x36 */
+export declare const digit6: number;
+/** 0x37 */
+export declare const digit7: number;
+/** 0x38 */
+export declare const digit8: number;
+/** 0x39 */
+export declare const digit9: number;
+/** 0x3A */
+export declare const colon: number;
+/** 0x3B */
+export declare const semicolon: number;
+/** 0x3C */
+export declare const lessThanSign: number;
+/** 0x3D */
+export declare const equalsSign: number;
+/** 0x3E */
+export declare const greaterThanSign: number;
+/** 0x3F */
+export declare const questionMark: number;
+/** 0x40 */
+export declare const commercialAt: number;
+/** 0x41..0x5A */
+export declare const latinCapitalLetterRange: Range;
+/** 0x41 */
+export declare const latinCapitalLetterA: number;
+/** 0x45 */
+export declare const latinCapitalLetterE: number;
+/** 0x46 */
+export declare const latinCapitalLetterF: number;
+/** 0x5B */
+export declare const leftSquareBracket: number;
+/** 0x5C */
+export declare const reverseSolidus: number;
+/** 0x5D */
+export declare const rightSquareBracket: number;
+/** 0x5E */
+export declare const circumflexAccent: number;
+/** 0x5F */
+export declare const lowLine: number;
+/** 0x60 */
+export declare const graveAccent: number;
+/** 0x61..0x7A */
+export declare const latinSmallLetterRange: Range;
+/** 0x61 */
+export declare const latinSmallLetterA: number;
+/** 0x62 */
+export declare const latinSmallLetterB: number;
+/** 0x65 */
+export declare const latinSmallLetterE: number;
+/** 0x66 */
+export declare const latinSmallLetterF: number;
+/** 0x6E */
+export declare const latinSmallLetterN: number;
+/** 0x72 */
+export declare const latinSmallLetterR: number;
+/** 0x74 */
+export declare const latinSmallLetterT: number;
+/** 0x75 */
+export declare const latinSmallLetterU: number;
+/** 0x7A */
+export declare const latinSmallLetterZ: number;
+/** 0x7B */
+export declare const leftCurlyBracket: number;
+/** 0x7C */
+export declare const verticalLine: number;
+/** 0x7D */
+export declare const rightCurlyBracket: number;
+/** 0x7E */
+export declare const tilde: number;

package/text/ascii/module.f.js

@@ -0,0 +1,148 @@
+import {} from "../../types/range/module.f.js";
+const at = s => i => {
+    const r = s.codePointAt(i);
+    if (r === void 0) {
+        throw s;
+    }
+    return r;
+};
+export const one = (s) => at(s)(0);
+export const range = s => {
+    const f = at(s);
+    const f0 = f(0);
+    if (s.length === 1) {
+        return [f0, f0];
+    }
+    return [f0, f(1)];
+};
+// 0x00..
+/** 0x08 */
+export const backspace = one('\b');
+/** 0x09 */
+export const ht = one('\t');
+/** 0x0A */
+export const lf = one('\n');
+/** 0x0C */
+export const ff = one('\f');
+/** 0x0D */
+export const cr = one('\r');
+// 0x20..
+/** 0x20 */
+export const space = one(' ');
+/** 0x21 */
+export const exclamationMark = one('!');
+/** 0x22 */
+export const quotationMark = one('"');
+/** 0x23 */
+export const numberSign = one('#');
+/** 0x24 */
+export const dollarSign = one('$');
+/** 0x25 */
+export const percentSign = one('%');
+/** 0x26 */
+export const ampersand = one('&');
+/** 0x27 */
+export const apostrophe = one("'");
+/** 0x28 */
+export const leftParenthesis = one('(');
+/** 0x29 */
+export const rightParenthesis = one(')');
+/** 0x2A */
+export const asterisk = one('*');
+/** 0x2B */
+export const plusSign = one('+');
+/** 0x2C */
+export const comma = one(',');
+/** 0x2D */
+export const hyphenMinus = one('-');
+/** 0x2E */
+export const fullStop = one('.');
+/** 0x2F */
+export const solidus = one('/');
+// 0x30..
+/** 0x30..0x39 */
+export const digitRange = range('09');
+/** 0x30 */
+export const digit0 = one('0');
+/** 0x31 */
+export const digit1 = one('1');
+/** 0x32 */
+export const digit2 = one('2');
+/** 0x33 */
+export const digit3 = one('3');
+/** 0x34 */
+export const digit4 = one('4');
+/** 0x35 */
+export const digit5 = one('5');
+/** 0x36 */
+export const digit6 = one('6');
+/** 0x37 */
+export const digit7 = one('7');
+/** 0x38 */
+export const digit8 = one('8');
+/** 0x39 */
+export const digit9 = one('9');
+/** 0x3A */
+export const colon = one(':');
+/** 0x3B */
+export const semicolon = one(';');
+/** 0x3C */
+export const lessThanSign = one('<');
+/** 0x3D */
+export const equalsSign = one('=');
+/** 0x3E */
+export const greaterThanSign = one('>');
+/** 0x3F */
+export const questionMark = one('?');
+// 0x40..
+/** 0x40 */
+export const commercialAt = one('@');
+/** 0x41..0x5A */
+export const latinCapitalLetterRange = range('AZ');
+/** 0x41 */
+export const latinCapitalLetterA = one('A');
+/** 0x45 */
+export const latinCapitalLetterE = one('E');
+/** 0x46 */
+export const latinCapitalLetterF = one('F');
+/** 0x5B */
+export const leftSquareBracket = one('[');
+/** 0x5C */
+export const reverseSolidus = one('\\');
+/** 0x5D */
+export const rightSquareBracket = one(']');
+/** 0x5E */
+export const circumflexAccent = one('^');
+/** 0x5F */
+export const lowLine = one('_');
+// 0x60..
+/** 0x60 */
+export const graveAccent = one('`');
+/** 0x61..0x7A */
+export const latinSmallLetterRange = range('az');
+/** 0x61 */
+export const latinSmallLetterA = one('a');
+/** 0x62 */
+export const latinSmallLetterB = one('b');
+/** 0x65 */
+export const latinSmallLetterE = one('e');
+/** 0x66 */
+export const latinSmallLetterF = one('f');
+/** 0x6E */
+export const latinSmallLetterN = one('n');
+/** 0x72 */
+export const latinSmallLetterR = one('r');
+/** 0x74 */
+export const latinSmallLetterT = one('t');
+/** 0x75 */
+export const latinSmallLetterU = one('u');
+/** 0x7A */
+export const latinSmallLetterZ = one('z');
+/** 0x7B */
+export const leftCurlyBracket = one('{');
+/** 0x7C */
+export const verticalLine = one('|');
+/** 0x7D */
+export const rightCurlyBracket = one('}');
+/** 0x7E */
+export const tilde = one('~');

package/text/ascii/test.f.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    range: () => void;
+};
+export default _default;

package/text/ascii/test.f.js

@@ -0,0 +1,14 @@
+import * as _ from "./module.f.js";
+const { range } = _;
+import * as json from "../../json/module.f.js";
+import * as o from "../../types/object/module.f.js";
+const { sort } = o;
+const stringify = json.stringify(sort);
+export default {
+    range: () => {
+        const r = stringify(range("A"));
+        if (r !== '[65,65]') {
+            throw r;
+        }
+    }
+};

package/text/module.f.d.ts

@@ -0,0 +1,8 @@
+import * as list from '../types/list/module.f.ts';
+export type Block = ItemThunk | ItemArray;
+type ItemArray = readonly Item[];
+type ItemThunk = () => list.List<Item>;
+export type Item = string | ItemArray | ItemThunk;
+export declare const flat: (indent: string) => (text: Block) => list.List<string>;
+export declare const curly: (type: string) => (name: string) => (body: Block) => Block;
+export {};

package/text/module.f.js

@@ -0,0 +1,10 @@
+import * as list from "../types/list/module.f.js";
+const { flatMap } = list;
+export const flat = indent => {
+    const f = prefix => {
+        const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
+        return flatMap(g);
+    };
+    return f('');
+};
+export const curly = type => name => body => [`${type} ${name}`, '{', body, '}'];

package/text/sgr/module.f.d.ts

@@ -0,0 +1,8 @@
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ */
+export declare const sgr: (c: number) => string;
+export declare const reset: string;
+export declare const bold: string;
+export declare const fgRed: string;
+export declare const fgGreen: string;

package/text/sgr/module.f.js

@@ -0,0 +1,8 @@
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ */
+export const sgr = c => `\x1b[${c.toString()}m`;
+export const reset = sgr(0);
+export const bold = sgr(1);
+export const fgRed = sgr(31);
+export const fgGreen = sgr(32);

package/text/test.f.d.ts

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

package/text/test.f.js

@@ -0,0 +1,18 @@
+import * as _ from "./module.f.js";
+import * as string from "../types/string/module.f.js";
+const { join } = string;
+export default () => {
+    const text = [
+        'a',
+        'b',
+        () => [
+            'c',
+            () => ['d'],
+        ],
+        'e',
+    ];
+    const result = join('\n')(_.flat(':')(text));
+    if (result !== 'a\nb\n:c\n::d\ne') {
+        throw result;
+    }
+};

package/text/utf16/module.f.d.ts

@@ -0,0 +1,9 @@
+import { type List, type Thunk } from '../../types/list/module.f.ts';
+type u16 = number;
+type i32 = number;
+export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
+declare const u16: (i: number) => boolean;
+export declare const toCodePointList: (input: List<u16>) => List<i32>;
+export declare const stringToList: (s: string) => List<u16>;
+export declare const listToString: (input: List<u16>) => string;
+export {};

package/text/utf16/module.f.js

@@ -0,0 +1,66 @@
+import { map, flat, stateScan, reduce, flatMap, empty, } from "../../types/list/module.f.js";
+import * as operator from "../../types/function/operator/module.f.js";
+import { contains } from "../../types/range/module.f.js";
+import * as f from "../../types/function/module.f.js";
+const { fn } = f;
+const lowBmp = contains([0x0000, 0xd7ff]);
+const highBmp = contains([0xe000, 0xffff]);
+const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint);
+const isHighSurrogate = contains([0xd800, 0xdbff]);
+const isLowSurrogate = contains([0xdc00, 0xdfff]);
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
+const codePointToUtf16 = codePoint => {
+    if (isBmpCodePoint(codePoint)) {
+        return [codePoint];
+    }
+    if (isSupplementaryPlane(codePoint)) {
+        const n = codePoint - 0x1_0000;
+        const high = (n >> 10) + 0xd800;
+        const low = (n & 0b0011_1111_1111) + 0xdc00;
+        return [high, low];
+    }
+    return [codePoint & 0xffff];
+};
+export const fromCodePointList = flatMap(codePointToUtf16);
+const u16 = contains([0x0000, 0xFFFF]);
+const utf16ByteToCodePointOp = state => word => {
+    if (!u16(word)) {
+        return [[0xffffffff], state];
+    }
+    if (state === null) {
+        if (isBmpCodePoint(word)) {
+            return [[word], null];
+        }
+        if (isHighSurrogate(word)) {
+            return [[], word];
+        }
+        return [[word | errorMask], null];
+    }
+    if (isLowSurrogate(word)) {
+        const high = state - 0xd800;
+        const low = word - 0xdc00;
+        return [[(high << 10) + low + 0x10000], null];
+    }
+    if (isBmpCodePoint(word)) {
+        return [[state | errorMask, word], null];
+    }
+    if (isHighSurrogate(word)) {
+        return [[state | errorMask], word];
+    }
+    return [[state | errorMask, word | errorMask], null];
+};
+const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask], null];
+const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input);
+const eofList = [null];
+export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const stringToList = s => {
+    const at = i => {
+        const first = s.charCodeAt(i);
+        return isNaN(first) ? empty : { first, tail: () => at(i + 1) };
+    };
+    return at(0);
+};
+export const listToString = fn(map(String.fromCharCode))
+    .then(reduce(operator.concat)(''))
+    .result;

package/text/utf16/test.f.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    toCodePointList: (() => void)[];
+    fromCodePointList: (() => void)[];
+    string: (() => void)[];
+};
+export default _default;