functionalscript 0.2.0 → 0.2.1

package/out/text/ascii/module.f.mjs

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

package/out/text/ascii/test.f.mjs

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

package/out/text/module.f.mjs

@@ -0,0 +1,19 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { flatMap } = list;
+/** @typedef {ItemThunk|ItemArray} Block */
+/** @typedef {readonly Item[]} ItemArray */
+/** @typedef {() => list.List<Item>} ItemThunk */
+/** @typedef {string|ItemArray|ItemThunk} Item */
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat = indent => {
+    /** @type {(prefix: string) => (text: Block) => list.List<string>} */
+    const f = prefix => {
+        /** @type {(item: Item) => list.List<string>} */
+        const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
+        return flatMap(g);
+    };
+    return f('');
+};
+/** @type {(type: string) => (name: string) => (body: Block) => Block} */
+export const curly = type => name => body => [`${type} ${name}`, '{', body, '}'];

package/out/text/sgr/module.f.mjs

@@ -0,0 +1,17 @@
+// @ts-self-types="./module.f.d.mts"
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+export const sgr = c => `\x1b[${c.toString()}m`;
+export const codes = {
+    /** @readonly */
+    reset: sgr(0),
+    /** @readonly */
+    bold: sgr(1),
+    /** @readonly */
+    fgRed: sgr(31),
+    /** @readonly */
+    fgGreen: sgr(32),
+};

package/out/text/test.f.mjs

@@ -0,0 +1,19 @@
+import * as _ from './module.f.mjs';
+import * as string from '../types/string/module.f.mjs';
+const { join } = string;
+export default () => {
+    /** @type {_.Block} */
+    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/out/text/utf16/module.f.mjs

@@ -0,0 +1,86 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../../types/list/module.f.mjs';
+import * as operator from '../../types/function/operator/module.f.mjs';
+import * as range from '../../types/range/module.f.mjs';
+const { contains } = range;
+import * as f from '../../types/function/module.f.mjs';
+const { fn } = f;
+const { map, flat, stateScan, reduce, flatMap, empty } = list;
+/** @typedef {u16|null} WordOrEof */
+/** @typedef {number|null} Utf16State */
+/** @typedef {number} u16 */
+/** @typedef {number} i32 */
+const lowBmp = contains([0x0000, 0xd7ff]);
+const highBmp = contains([0xe000, 0xffff]);
+/** @type {(codePoint: i32) => boolean} */
+const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint);
+/** @type {(codePoint: i32) => boolean} */
+const isHighSurrogate = contains([0xd800, 0xdbff]);
+/** @type {(codePoint: i32) => boolean} */
+const isLowSurrogate = contains([0xdc00, 0xdfff]);
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+/** @type {(a: i32) => boolean} */
+const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
+/** @type {(input: i32) => list.List<u16>} */
+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]);
+/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
+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];
+};
+/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
+const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask], null];
+/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
+const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input);
+/** @type {list.List<WordOrEof>} */
+const eofList = [null];
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList = s => {
+    /** @type {(i: number) => list.Result<number>} */
+    const at = i => {
+        const first = s.charCodeAt(i);
+        return isNaN(first) ? empty : { first, tail: () => at(i + 1) };
+    };
+    return at(0);
+};
+/** @type {(input: list.List<u16>) => string} */
+export const listToString = fn(map(String.fromCharCode))
+    .then(reduce(operator.concat)(''))
+    .result;

package/out/text/utf16/test.f.mjs

@@ -0,0 +1,145 @@
+import * as encoding from './module.f.mjs';
+import * as json from '../../json/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { sort } = o;
+import * as list from '../../types/list/module.f.mjs';
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a);
+export default {
+    toCodePointList: [
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([-1, 65536])));
+            if (result !== '[4294967295,4294967295]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([0, 36, 8364, 55295, 57344, 65535])));
+            if (result !== '[0,36,8364,55295,57344,65535]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([56320, 57343])));
+            if (result !== '[-2147427328,-2147426305]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])));
+            if (result !== '[65536,66615,150370,1114111]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([55296, 55296])));
+            if (result !== '[-2147428352,-2147428352]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([55296, 0])));
+            if (result !== '[-2147428352,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([56320])));
+            if (result !== '[-2147427328]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([56320, 0])));
+            if (result !== '[-2147427328,0]') {
+                throw result;
+            }
+        }
+    ],
+    fromCodePointList: [
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0])));
+            if (result !== '[0]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x24])));
+            if (result !== '[36]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x20AC])));
+            if (result !== '[8364]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xd7ff])));
+            if (result !== '[55295]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xe000])));
+            if (result !== '[57344]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])));
+            if (result !== '[65535]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])));
+            if (result !== '[55296,56320]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10437])));
+            if (result !== '[55297,56375]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x24B62])));
+            if (result !== '[55378,57186]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10ffff])));
+            if (result !== '[56319,57343]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([-1, 0xd800, 0xdfff, 0x110000])));
+            if (result !== '[65535,55296,57343,0]') {
+                throw result;
+            }
+        }
+    ],
+    string: [
+        () => {
+            const utf16List = encoding.stringToList("Hello world!😂🚜🚲");
+            const result = encoding.listToString(utf16List);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        },
+        () => {
+            const a = encoding.stringToList("Hello world!😂🚜🚲");
+            const b = encoding.toCodePointList(a);
+            const c = encoding.fromCodePointList(b);
+            const result = encoding.listToString(c);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        }
+    ]
+};

package/out/text/utf8/module.f.mjs

@@ -0,0 +1,126 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../../types/list/module.f.mjs';
+import * as operator from '../../types/function/operator/module.f.mjs';
+import * as Array from '../../types/array/module.f.mjs';
+const { flatMap, flat, stateScan } = list;
+/** @typedef {u8|null} ByteOrEof */
+/** @typedef {Array.Array1<number>|Array.Array2<number>|Array.Array3<number>} Utf8NonEmptyState */
+/** @typedef {null|Utf8NonEmptyState} Utf8State */
+/** @typedef {number} u8 */
+/** @typedef {number} i32 */
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+/** @type {(input:number) => list.List<u8>} */
+const codePointToUtf8 = input => {
+    if (input >= 0x0000 && input <= 0x007f) {
+        return [input & 0b01111_1111];
+    }
+    if (input >= 0x0080 && input <= 0x07ff) {
+        return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000];
+    }
+    if (input >= 0x0800 && input <= 0xffff) {
+        return [input >> 12 | 0b1110_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000];
+    }
+    if (input >= 0x10000 && input <= 0x10ffff) {
+        return [input >> 18 | 0b1111_0000, input >> 12 & 0b0011_1111 | 0b1000_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000];
+    }
+    if ((input & errorMask) !== 0) {
+        if ((input & 0b1000_0000_0000_0000) !== 0) {
+            return [input >> 12 & 0b0000_0111 | 0b1111_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000];
+        }
+        if ((input & 0b0000_0100_0000_0000) !== 0) {
+            return [input >> 6 & 0b0000_1111 | 0b1110_0000, input & 0b0011_1111 | 0b1000_0000];
+        }
+        if ((input & 0b0000_0010_0000_0000) !== 0) {
+            return [input >> 6 & 0b0000_0111 | 0b1111_0000, input & 0b0011_1111 | 0b1000_0000];
+        }
+        if ((input & 0b0000_0000_1000_0000) !== 0) {
+            return [input & 0b1111_1111];
+        }
+    }
+    return [errorMask];
+};
+export const fromCodePointList = flatMap(codePointToUtf8);
+/** @type {(state: Utf8NonEmptyState) => i32}*/
+const utf8StateToError = state => {
+    let x;
+    switch (state.length) {
+        case 1: {
+            [x] = state;
+            break;
+        }
+        case 2: {
+            const [s0, s1] = state;
+            x = s0 < 0b1111_0000
+                ? ((s0 & 0b0000_1111) << 6) + (s1 & 0b0011_1111) + 0b0000_0100_0000_0000
+                : ((s0 & 0b0000_0111) << 6) + (s1 & 0b0011_1111) + 0b0000_0010_0000_0000;
+            break;
+        }
+        case 3: {
+            const [s0, s1, s2] = state;
+            x = ((s0 & 0b0000_0111) << 12) + ((s1 & 0b0011_1111) << 6) + (s2 & 0b0011_1111) + 0b1000_0000_0000_0000;
+            break;
+        }
+        default:
+            throw 'invalid state';
+    }
+    return x | errorMask;
+};
+/** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
+const utf8ByteToCodePointOp = state => byte => {
+    if (byte < 0x00 || byte > 0xff) {
+        return [[errorMask], state];
+    }
+    if (state === null) {
+        if (byte < 0b1000_0000) {
+            return [[byte], null];
+        }
+        if (byte >= 0b1100_0010 && byte <= 0b1111_0100) {
+            return [[], [byte]];
+        }
+        return [[byte | errorMask], null];
+    }
+    if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
+        switch (state.length) {
+            case 1: {
+                const [s0] = state;
+                if (s0 < 0b1110_0000) {
+                    return [[((s0 & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null];
+                }
+                if (s0 < 0b1111_1000) {
+                    return [[], [s0, byte]];
+                }
+                break;
+            }
+            case 2: {
+                const [s0, s1] = state;
+                if (s0 < 0b1111_0000) {
+                    return [[((s0 & 0b0000_1111) << 12) + ((s1 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null];
+                }
+                if (s0 < 0b1111_1000) {
+                    return [[], [s0, s1, byte]];
+                }
+                break;
+            }
+            case 3: {
+                const [s0, s1, s2] = state;
+                return [[((s0 & 0b0000_0111) << 18) + ((s1 & 0b0011_1111) << 12) + ((s2 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null];
+            }
+        }
+    }
+    const error = utf8StateToError(state);
+    if (byte < 0b1000_0000) {
+        return [[error, byte], null];
+    }
+    if (byte >= 0b1100_0010 && byte <= 0b1111_0100) {
+        return [[error], [byte]];
+    }
+    return [[error, byte | errorMask], null];
+};
+/** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
+const utf8EofToCodePointOp = state => [state === null ? null : [utf8StateToError(state)], null];
+/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
+const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input);
+/** @type {list.List<ByteOrEof>} */
+const eofList = [null];
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])));