functionalscript 0.2.6 → 0.3.1

package/out/types/sorted_set/test.f.mjs

@@ -1,80 +0,0 @@
-import * as _ from './module.f.mjs';
-import * as compare from '../function/compare/module.f.mjs';
-const { unsafeCmp } = compare;
-import * as json from '../../json/module.f.mjs';
-import * as object from '../object/module.f.mjs';
-const { sort } = object;
-import * as list from '../list/module.f.mjs';
-const { toArray, countdown, length } = list;
-import * as Map from '../map/module.f.mjs';
-import * as f from '../function/module.f.mjs';
-const { flip } = f;
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a);
-/** @type {<T>(a: T) => (b: T) => Map.Sign} */
-const reverseCmp = flip(unsafeCmp);
-export default {
-    union: [
-        () => {
-            const result = stringify(toArray(_.union(unsafeCmp)([2, 3, 4])([1, 3, 5])));
-            if (result !== '[1,2,3,4,5]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(toArray(_.union(unsafeCmp)([1, 2, 3])([])));
-            if (result !== '[1,2,3]') {
-                throw result;
-            }
-        },
-        () => {
-            const n = 10_000;
-            const sortedSet = toArray(countdown(n));
-            const result = _.union(reverseCmp)(sortedSet)(sortedSet);
-            const len = length(result);
-            if (len != n) {
-                throw result;
-            }
-        }
-    ],
-    intersect: [
-        () => {
-            const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])));
-            if (result !== '[3]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(toArray(_.intersect(unsafeCmp)([1, 2, 3])([])));
-            if (result !== '[]') {
-                throw result;
-            }
-        }
-    ],
-    has: [
-        () => {
-            const result = _.has(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (!result) {
-                throw result;
-            }
-        },
-        () => {
-            const result = _.has(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result) {
-                throw result;
-            }
-        },
-        () => {
-            const result = _.has(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (result) {
-                throw result;
-            }
-        },
-        () => {
-            const result = _.has(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
-            if (!result) {
-                throw result;
-            }
-        }
-    ]
-};

package/out/types/string/module.f.d.mts

@@ -1,9 +0,0 @@
-export const join: f.Func<string, (input: list.List<string>) => string>;
-export const concat: (input: list.List<string>) => string;
-/** @type {(n: string) => (v: number) => string} */
-export const repeat: (n: string) => (v: number) => string;
-/** @type {(a: string) => (b: string) => compare.Sign} */
-export const cmp: (a: string) => (b: string) => compare.Sign;
-import * as list from '../list/module.f.mjs';
-import * as f from '../function/module.f.mjs';
-import * as compare from '../function/compare/module.f.mjs';

package/out/types/string/module.f.mjs

@@ -1,17 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../list/module.f.mjs';
-const { reduce: listReduce, repeat: listRepeat } = list;
-import * as f from '../function/module.f.mjs';
-const { compose } = f;
-import * as compare from '../function/compare/module.f.mjs';
-const { unsafeCmp } = compare;
-import * as op from '../function/operator/module.f.mjs';
-const { join: joinOp, concat: concatOp } = op;
-/** @type {(o: op.Reduce<string>) => (input: list.List<string>) => string} */
-const reduce = o => listReduce(o)('');
-export const join = compose(joinOp)(reduce);
-export const concat = reduce(concatOp);
-/** @type {(n: string) => (v: number) => string} */
-export const repeat = v => compose(listRepeat(v))(concat);
-/** @type {(a: string) => (b: string) => compare.Sign} */
-export const cmp = unsafeCmp;

package/out/types/string/test.f.d.mts

@@ -1,15 +0,0 @@
-declare namespace _default {
-    let join: {
-        0: () => void;
-        1: () => void;
-        3: () => void;
-    };
-    function concat(): void;
-    let repeatList: {
-        0: () => void;
-        5: () => void;
-    };
-    function repeat(): void;
-    function cmp(): void;
-}
-export default _default;

package/out/types/string/test.f.mjs

@@ -1,58 +0,0 @@
-import * as _ from './module.f.mjs';
-const { join, concat, repeat, cmp } = _;
-import * as list from '../list/module.f.mjs';
-const { repeat: repeatList } = list;
-export default {
-    join: {
-        0: () => {
-            const result = join('/')([]);
-            if (result !== '') {
-                throw result;
-            }
-        },
-        1: () => {
-            const result = join('/')(['']);
-            if (result !== '') {
-                throw result;
-            }
-        },
-        3: () => {
-            const result = join(' ')(['hello', 'world', '!']);
-            if (result !== 'hello world !') {
-                throw result;
-            }
-        }
-    },
-    concat: () => {
-        const result = concat(['hello', 'world']);
-        if (result !== 'helloworld') {
-            throw result;
-        }
-    },
-    repeatList: {
-        0: () => {
-            const s = join('.')(repeatList('x')(0));
-            if (s != '') {
-                throw s;
-            }
-        },
-        5: () => {
-            const s = join('.')(repeatList('x')(5));
-            if (s != 'x.x.x.x.x') {
-                throw s;
-            }
-        }
-    },
-    repeat: () => {
-        const s = repeat('x')(5);
-        if (s != 'xxxxx') {
-            throw s;
-        }
-    },
-    cmp: () => {
-        const result = cmp('3')('4');
-        if (result !== -1) {
-            throw result;
-        }
-    }
-};

package/out/types/string_set/module.f.d.mts

@@ -1,13 +0,0 @@
-export const values: <T>(tree: BtreeTypes.Tree<T>) => list.List<T>;
-export const empty: null;
-/** @typedef {BtreeTypes.Tree<string>} StringSet */
-/** @type {(value: string) => (set: StringSet) => boolean} */
-export const contains: (value: string) => (set: StringSet) => boolean;
-/** @type {(value: string) => (s: StringSet) => StringSet} */
-export const set: (value: string) => (s: StringSet) => StringSet;
-export const fromValues: (input: list.List<string>) => StringSet;
-/** @type {(value: string) => (s: StringSet) => StringSet} */
-export const remove: (value: string) => (s: StringSet) => StringSet;
-export type StringSet = BtreeTypes.Tree<string>;
-import * as BtreeTypes from '../btree/types/module.f.mjs';
-import * as list from '../list/module.f.mjs';

package/out/types/string_set/module.f.mjs

@@ -1,29 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as BtreeTypes from '../btree/types/module.f.mjs';
-import * as btree from '../btree/module.f.mjs';
-import * as btf from '../btree/find/module.f.mjs';
-const { find, isFound } = btf;
-import * as btr from '../btree/remove/module.f.mjs';
-const { remove: btreeRemove } = btr;
-import * as bts from '../btree/set/module.f.mjs';
-const { set: btreeSet } = bts;
-export const { 
-/** @type {(s: StringSet) => list.List<string>} */
-values, empty, } = btree;
-import * as string from "../string/module.f.mjs";
-const { cmp } = string;
-import * as list from '../list/module.f.mjs';
-const { fold } = list;
-import * as f from '../function/module.f.mjs';
-const { compose } = f;
-/** @typedef {BtreeTypes.Tree<string>} StringSet */
-/** @type {(value: string) => (set: StringSet) => boolean} */
-export const contains = value => {
-    const f = find(cmp(value));
-    return s => s !== null && isFound(f(s).first);
-};
-/** @type {(value: string) => (s: StringSet) => StringSet} */
-export const set = value => btreeSet(cmp(value))(() => value);
-export const fromValues = fold(set)(null);
-/** @type {(value: string) => (s: StringSet) => StringSet} */
-export const remove = compose(cmp)(btreeRemove);

package/out/types/string_set/test.f.d.mts

@@ -1,5 +0,0 @@
-declare namespace _default {
-    function contains(): void;
-    function remove(): void;
-}
-export default _default;

package/out/types/string_set/test.f.mjs

@@ -1,65 +0,0 @@
-import * as _ from './module.f.mjs';
-export default {
-    contains: () => {
-        const r = _.set('hello')(null);
-        if (!_.contains('hello')(r)) {
-            throw r;
-        }
-        if (_.contains('hello1')(r)) {
-            throw r;
-        }
-    },
-    remove: () => {
-        let r = _.set('hello')(null);
-        r = _.set('world')(r);
-        r = _.set('HELLO')(r);
-        r = _.set('WORLD!')(r);
-        if (!_.contains('hello')(r)) {
-            throw r;
-        }
-        if (_.contains('hello1')(r)) {
-            throw r;
-        }
-        if (!_.contains('HELLO')(r)) {
-            throw r;
-        }
-        if (_.contains('WORLD')(r)) {
-            throw r;
-        }
-        if (!_.contains('world')(r)) {
-            throw r;
-        }
-        if (_.contains('world!')(r)) {
-            throw r;
-        }
-        if (!_.contains('WORLD!')(r)) {
-            throw r;
-        }
-        //
-        r = _.remove('hello')(r);
-        if (_.contains('hello')(r)) {
-            throw r;
-        }
-        if (!_.contains('world')(r)) {
-            throw r;
-        }
-        r = _.remove('world')(r);
-        if (_.contains('world')(r)) {
-            throw r;
-        }
-        if (!_.contains('HELLO')(r)) {
-            throw r;
-        }
-        r = _.remove('HELLO')(r);
-        if (_.contains('HELLO')(r)) {
-            throw r;
-        }
-        if (!_.contains('WORLD!')(r)) {
-            throw r;
-        }
-        r = _.remove('WORLD!')(r);
-        if (r !== null) {
-            throw r;
-        }
-    }
-};

package/text/module.f.mjs

@@ -1,27 +0,0 @@
-// @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/text/utf16/module.f.mjs

@@ -1,96 +0,0 @@
-// @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/types/array/module.f.mjs

@@ -1,119 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as option from '../nullable/module.f.mjs'
-const { map } = option
-
-/**
- * @template T
- * @typedef {readonly[T]} Array1
- */
-
-/** @typedef {0} Index1 */
-
-/**
- * @template T
- * @typedef {readonly[T, T]} Array2
- */
-
-/**
- * @template T0
- * @template T1
- * @typedef {readonly[T0, T1]} Tuple2
- */
-
-/** @typedef {0|1} Index2 */
-
-/**
- * @template T
- * @typedef {readonly[T, T, T]} Array3
- */
-
-/**
- * @template T0
- * @template T1
- * @template T2
- * @typedef {readonly[T0, T1, T2]} Tuple3
- */
-
-/** @typedef {0|1|2} Index3 */
-
-/**
- * @template T
- * @typedef {readonly[T, T, T, T]} Array4
- */
-
-/** @typedef {0|1|2|3} Index4 */
-
-/**
- * @template T
- * @typedef {readonly[T, T, T, T, T]} Array5
- */
-
-/**
- * @template T
- * @typedef {readonly[T, T, T, T, T, T, T, T]} Array8
- */
-
-/**
- * @template T
- * @typedef {readonly[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]} Array16
- */
-
-/** @typedef {0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15} Index16 */
-
-/**
- * @template T
- * @typedef {Array1<T>| Array2<T> | Array3<T> | Array4<T> | Array5<T>} Array1_5
- */
-
-/** @typedef {0|1|2|3|4} Index5 */
-
-/**
- * @template T
- * @typedef {T extends Array1<infer _> ? Index1 :
- *  T extends Array2<infer _> ? Index2 :
- *  T extends Array3<infer _> ? Index3 :
- *  T extends Array4<infer _> ? Index4 :
- *  T extends Array5<infer _> ? Index5 :
- *  T extends readonly (infer _)[] ? number :
- *  never
- * } KeyOf
- */
-
-/** @type {<T>(_: readonly T[]) => readonly T[]} */
-const uncheckTail = a => a.slice(1)
-
-/** @type {<T>(_: readonly T[]) => readonly T[]} */
-const uncheckHead = a => a.slice(0, -1)
-
-/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
-export const at = i => a => {
-    const r = a[i]
-    return r === void 0 ? null : r
-}
-
-/** @type {<T>(_: readonly T[]) => T|null} */
-export const first = at(0)
-
-/** @type {<T>(_: readonly T[]) => T|null} */
-export const last = a => at(a.length - 1)(a)
-
-/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
-export const tail = a => a.length === 0 ? null : uncheckTail(a)
-
-/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
-export const splitFirst = a => {
-    /** @typedef {typeof a[0]} T*/
-    /** @type {(_: T) => readonly[T, readonly T[]]} */
-    const split = first => [first, uncheckTail(a)]
-    return map(split)(first(a))
-}
-
-/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
-export const head = a => a.length === 0 ? null : uncheckHead(a)
-
-/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
-export const splitLast = a => {
-    const lastA = last(a)
-    if (lastA === null) { return null }
-    return [uncheckHead(a), lastA]
-}

package/types/btree/find/module.f.mjs

@@ -1,125 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as _ from '../types/module.f.mjs'
-import * as List from '../../list/module.f.mjs'
-import * as cmp from '../../function/compare/module.f.mjs'
-const { index3, index5 } = cmp
-import * as Array from '../../array/module.f.mjs'
-
-/**
- * @template T
- * @typedef {readonly[cmp.Index3, _.Leaf1<T>]} FirstLeaf1
- */
-
-/**
- * @template T
- * @typedef {readonly[1, _.Branch3<T>]} FirstBranch3
- */
-
-/**
- * @template T
- * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
- */
-
-/**
- * @template T
- * @typedef {readonly[1|3, _.Branch5<T>]} FirstBranch5
- */
-
-/**
- * @template T
- * @typedef {FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>} First
- */
-
-/**
- * @template T
- * @typedef {readonly[0|2, _.Branch3<T>]} PathItem3
- */
-
-/**
- * @template T
- * @typedef {readonly[0|2|4, _.Branch5<T>]} PathItem5
- */
-
-/**
- * @template T
- * @typedef {PathItem3<T> | PathItem5<T>} PathItem
- */
-
-/** @type {<T>(item: PathItem<T>) => _.Node<T>} */
-const child = item =>
-    /** @type {typeof item extends PathItem<infer T> ? _.Node<T> : never} */(item[1][item[0]])
-
-/**
- * @template T
- * @typedef {List.List<PathItem<T>>} Path
- */
-
-/**
- * @template T
- * @typedef {{
- *  readonly first: First<T>,
- *  readonly tail: Path<T>
- * }} Result<T>
- */
-
-/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
-export const find = c => {
-    const i3 = index3(c)
-    const i5 = index5(c)
-    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
-    /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
-    const f = tail => node => {
-        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
-        const append = index => {
-            const first = /** @type {PathItem<T>} */([index, node])
-            return f({ first, tail })(child(first))
-        }
-        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
-        const done = index => ({ first: /** @type {First<T>} */([index, node]), tail })
-        switch (node.length) {
-            case 1: { return done(i3(node[0])) }
-            case 2: { return done(i5(node)) }
-            case 3: {
-                const i = i3(node[1])
-                switch (i) {
-                    case 0: case 2: { return append(i) }
-                    case 1: { return done(i) }
-                }
-            }
-            case 5: {
-                const i = i5([node[1], node[3]])
-                switch (i) {
-                    case 0: case 2: case 4: { return append(i) }
-                    case 1: case 3: { return done(i) }
-                }
-            }
-        }
-    }
-    return f(null)
-}
-
-/** @type {<T>(first: First<T>) => boolean} */
-export const isFound = ([i]) => {
-    switch (i) {
-        case 1: case 3: { return true }
-        default: { return false }
-    }
-}
-
-/** @type {<T>(first: First<T>) => T | null} */
-export const value = ([i, r]) => {
-    switch (i) {
-        case 1: {
-            switch (r.length) {
-                case 1: case 2: { return r[0] }
-                default: { return r[1] }
-            }
-        }
-        case 3: {
-            return r.length === 2 ? r[1] : r[3]
-        }
-        default: {
-            return null
-        }
-    }
-}