functionalscript 0.3.4 → 0.3.6

package/types/bit_vec/test.f.js

@@ -0,0 +1,210 @@
+import { empty, vec, length, concatLsb, uintLsb, uintMsb, removeLsb, concatMsb, removeMsb, uint, popUintLsb, popUintMsb } from "./module.f.js";
+export default {
+    examples: {
+        vec: () => {
+            const vec4 = vec(4n);
+            const v0 = vec4(5n); // 0x15n
+            if (v0 !== 0x15n) {
+                throw v0;
+            }
+            const v1 = vec4(0x5fen); // 0x1En
+            if (v1 !== 0x1en) {
+                throw v1;
+            }
+        },
+        uint: () => {
+            const vector = vec(8n)(0x5n); // 0x105n
+            if (vector !== 0x105n) {
+                throw vector;
+            }
+            const result = uint(vector); // result is 0x5n
+            if (result !== 0x5n) {
+                throw result;
+            }
+        },
+        uintLsb: () => {
+            const vector = vec(8n)(0xf5n); // 0x1F5n
+            if (vector !== 0x1f5n) {
+                throw vector;
+            }
+            const result = uintLsb(4n)(vector); // result is 5n
+            if (result !== 5n) {
+                throw result;
+            }
+            const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
+            if (result2 !== 0xf5n) {
+                throw result2;
+            }
+        },
+        uintMsb: () => {
+            const vector = vec(8n)(0xf5n); // 0x1F5n
+            if (vector !== 0x1f5n) {
+                throw vector;
+            }
+            const result = uintMsb(4n)(vector); // result is 0xFn
+            if (result !== 0xfn) {
+                throw result;
+            }
+            const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
+            if (result2 !== 0xf500n) {
+                throw result2;
+            }
+        },
+        popUintLsb: () => {
+            const vector = vec(8n)(0xf5n); // 0x1F5n
+            const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
+            if (result !== 5n) {
+                throw result;
+            }
+            if (rest !== 0x1fn) {
+                throw rest;
+            }
+            const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
+            if (result2 !== 0xf5n) {
+                throw result2;
+            }
+            if (rest2 !== 1n) {
+                throw rest2;
+            }
+        },
+        popUintMsb: () => {
+            const vector = vec(8n)(0xf5n); // 0x1F5n
+            const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
+            if (result !== 0xfn) {
+                throw result;
+            }
+            if (rest !== 0x15n) {
+                throw rest;
+            }
+            const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
+            if (result2 !== 0xf500n) {
+                throw result2;
+            }
+            if (rest2 !== 1n) {
+                throw rest2;
+            }
+        },
+        concatLsb: () => {
+            const u8 = vec(8n);
+            const a = u8(0x45n); // 0x145n
+            if (a !== 0x145n) {
+                throw a;
+            }
+            const b = u8(0x89n); // 0x189n
+            if (b !== 0x189n) {
+                throw b;
+            }
+            const ab = concatLsb(a)(b); // 0x18945n
+            if (ab !== 0x18945n) {
+                throw ab;
+            }
+        },
+        concatMsb: () => {
+            const u8 = vec(8n);
+            const a = u8(0x45n); // 0x145n
+            if (a !== 0x145n) {
+                throw a;
+            }
+            const b = u8(0x89n); // 0x189n
+            if (b !== 0x189n) {
+                throw b;
+            }
+            const ab = concatMsb(a)(b); // 0x14589n
+            if (ab !== 0x14589n) {
+                throw ab;
+            }
+        },
+        removeLsb: () => {
+            const v = vec(16n)(0x3456n); // 0x13456n
+            if (v !== 0x13456n) {
+                throw v;
+            }
+            const r = removeLsb(4n)(v); // 0x1345n
+            if (r !== 0x1345n) {
+                throw r;
+            }
+            const r2 = removeLsb(24n)(v); // 0x1n
+            if (r2 !== 0x1n) {
+                throw r2;
+            }
+        },
+        removeMsb: () => {
+            const v = vec(16n)(0x3456n); // 0x13456n
+            if (v !== 0x13456n) {
+                throw v;
+            }
+            const r = removeMsb(4n)(v); // 0x1456n
+            if (r !== 0x1456n) {
+                throw r;
+            }
+            const r2 = removeMsb(24n)(v); // 0x1n
+            if (r2 !== 0x1n) {
+                throw r2;
+            }
+        }
+    },
+    uintLsb: () => {
+        const vector = 117n;
+        const extract3Bits = uintLsb(3n);
+        const result = extract3Bits(vector); // result is 0b101n (5n)
+        if (result !== 5n) {
+            throw result;
+        }
+    },
+    uintSmall: () => {
+        const vector = 3n;
+        const extract3Bits = uintLsb(3n)(vector);
+        if (extract3Bits !== 1n) {
+            throw extract3Bits;
+        }
+    },
+    vecExample: () => {
+        const createVector = vec(4n);
+        const vector = createVector(5n); // vector is 0b10101n
+        if (vector !== 21n) {
+            throw vector;
+        }
+    },
+    length: () => {
+        const i = length(empty);
+        if (i !== 0n) {
+            throw i;
+        }
+    },
+    bitset: () => {
+        const v = vec(8n)(0x5fen);
+        if (v !== 0x1fen) {
+            throw v;
+        }
+        if (length(v) !== 8n) {
+            throw 'len';
+        }
+        const u = uintLsb(8n)(v);
+        if (u !== 0xfen) {
+            throw v;
+        }
+    },
+    appendBack: () => {
+        const vec8 = vec(8n);
+        const a = vec8(0x345n);
+        const b = vec8(0x789n);
+        const ab = concatLsb(a)(b);
+        if (ab !== 0x18945n) {
+            throw ab;
+        }
+        const s = length(ab);
+        if (s !== 16n) {
+            throw `appendBack: ${s}`;
+        }
+    },
+    removeBack: () => {
+        const v = vec(17n)(0x12345n);
+        if (v !== 0x32345n) {
+            throw v.toString(16);
+        }
+        const r = removeLsb(9n)(v);
+        if (r !== 0x191n) {
+            throw r.toString(16);
+        }
+    }
+};

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

@@ -0,0 +1,20 @@
+import * as _ from '../types/module.f.ts';
+import * as List from '../../list/module.f.ts';
+import * as cmp from '../../function/compare/module.f.ts';
+type FirstLeaf1<T> = readonly [cmp.Index3, _.Leaf1<T>];
+type FirstBranch3<T> = readonly [1, _.Branch3<T>];
+type FirstLeaf2<T> = readonly [cmp.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 PathItem<T> = PathItem3<T> | PathItem5<T>;
+export type Path<T> = List.List<PathItem<T>>;
+export type Result<T> = {
+    readonly first: First<T>;
+    readonly tail: Path<T>;
+};
+export declare const find: <T>(c: cmp.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 {};

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

@@ -0,0 +1,84 @@
+import * as _ from "../types/module.f.js";
+import * as List from "../../list/module.f.js";
+import * as cmp from "../../function/compare/module.f.js";
+const { index3, index5 } = cmp;
+import * as Array from "../../array/module.f.js";
+const child = (item) => item[1][item[0]];
+export const find = (c) => {
+    const i3 = index3(c);
+    const i5 = index5(c);
+    const f = (tail) => (node) => {
+        const append = index => {
+            const first = [index, node];
+            return f({ first, tail })(child(first));
+        };
+        const done = index => ({ first: [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);
+};
+export const isFound = ([i]) => {
+    switch (i) {
+        case 1:
+        case 3: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+};
+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;
+        }
+    }
+};

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

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

package/types/btree/find/test.f.js

@@ -0,0 +1,152 @@
+import * as _ from "./module.f.js";
+import * as list from "../../list/module.f.js";
+import * as json from "../../../json/module.f.js";
+import * as o from "../../object/module.f.js";
+const { sort } = o;
+import * as btree from "../types/module.f.js";
+import * as string from "../../string/module.f.js";
+const { cmp } = string;
+import * as s from "../set/module.f.js";
+const jsonStr = json.stringify(sort);
+const set = node => value => s.set(cmp(value))(() => value)(node);
+const str = r => jsonStr(list.toArray(list.map((x) => x[0])(r)));
+const find = i => m => str(_.find(cmp(i))(m));
+const test = () => {
+    let _map = ['1'];
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString());
+    {
+        const s = jsonStr(_map);
+        if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
+            throw s;
+        }
+    }
+    //
+    {
+        const r = find("0")(_map);
+        if (r !== '[0,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("1")(_map);
+        if (r !== '[1,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("10")(_map);
+        if (r !== '[2,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("100")(_map);
+        if (r !== '[3,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("12")(_map);
+        if (r !== '[4,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("16")(_map);
+        if (r !== '[1,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("17")(_map);
+        if (r !== '[0,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("25")(_map);
+        if (r !== '[1,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("26")(_map);
+        if (r !== '[2,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("36")(_map);
+        if (r !== '[3,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("37")(_map);
+        if (r !== '[4,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("4")(_map);
+        if (r !== '[1]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("41")(_map);
+        if (r !== '[0,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("49")(_map);
+        if (r !== '[1,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("5")(_map);
+        if (r !== '[2,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("64")(_map);
+        if (r !== '[1,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("65")(_map);
+        if (r !== '[0,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("81")(_map);
+        if (r !== '[1,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("85")(_map);
+        if (r !== '[2,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("9")(_map);
+        if (r !== '[3,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("91")(_map);
+        if (r !== '[4,2,2]') {
+            throw r;
+        }
+    }
+};
+export default test;

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

@@ -0,0 +1,4 @@
+import * as list from '../list/module.f.ts';
+import * as _ from './types/module.f.ts';
+export declare const empty: null;
+export declare const values: <T>(tree: _.Tree<T>) => list.List<T>;

package/types/btree/module.f.js

@@ -0,0 +1,31 @@
+import * as list from "../list/module.f.js";
+const { flat } = list;
+import * as n from "../nullable/module.f.js";
+const { map } = n;
+import * as _ from "./types/module.f.js";
+const nodeValues = node => () => {
+    switch (node.length) {
+        case 1:
+        case 2: {
+            return node;
+        }
+        case 3: {
+            return flat([
+                nodeValues(node[0]),
+                [node[1]],
+                nodeValues(node[2])
+            ]);
+        }
+        default: {
+            return flat([
+                nodeValues(node[0]),
+                [node[1]],
+                nodeValues(node[2]),
+                [node[3]],
+                nodeValues(node[4])
+            ]);
+        }
+    }
+};
+export const empty = null;
+export const values = map(nodeValues);

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

@@ -0,0 +1,4 @@
+import * as _ from '../types/module.f.ts';
+import * as Cmp from '../../function/compare/module.f.ts';
+export declare const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.TNode<T>) => _.Tree<T>;
+export declare const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;

package/types/btree/remove/module.f.js

@@ -0,0 +1,174 @@
+import * as _ from "../types/module.f.js";
+import * as Cmp from "../../function/compare/module.f.js";
+import * as find from "../find/module.f.js";
+import * as list from "../../list/module.f.js";
+const { fold, concat, next } = list;
+import * as Array from "../../array/module.f.js";
+import * as n from "../../nullable/module.f.js";
+const { map } = n;
+const path = tail => n => {
+    switch (n.length) {
+        case 1: {
+            return [n[0], { first: null, tail }];
+        }
+        case 2: {
+            return [n[0], { first: [n[1]], tail }];
+        }
+        case 3: {
+            return path({ first: [0, n], tail })(n[0]);
+        }
+        case 5: {
+            return path({ first: [0, n], tail })(n[0]);
+        }
+    }
+};
+const reduceValue0 = a => n => {
+    const [, v1, n2] = n;
+    if (a.length === 1) {
+        switch (n2.length) {
+            case 3: {
+                return [[a[0], v1, ...n2]];
+            }
+            case 5: {
+                return [[a[0], v1, n2[0]], n2[1], [n2[2], n2[3], n2[4]]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [a, v1, n2];
+    }
+};
+const reduceValue2 = a => n => {
+    const [n0, v1,] = n;
+    if (a.length === 1) {
+        switch (n0.length) {
+            case 3: {
+                return [[...n0, v1, a[0]]];
+            }
+            case 5: {
+                return [[n0[0], n0[1], n0[2]], n0[3], [n0[4], v1, a[0]]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [n0, v1, a];
+    }
+};
+const initValue0 = a => n => {
+    const [, v1, n2] = n;
+    if (a === null) {
+        switch (n2.length) {
+            case 1: {
+                return [[v1, ...n2]];
+            }
+            case 2: {
+                return [[v1], n2[0], [n2[1]]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [a, v1, n2];
+    }
+};
+const initValue1 = a => n => {
+    const [n0, v1] = n;
+    if (a === null) {
+        switch (n0.length) {
+            case 1: {
+                return [[...n0, v1]];
+            }
+            case 2: {
+                return [[n0[0]], n0[1], [v1]];
+            }
+            default: {
+                throw 'invalid node';
+            }
+        }
+    }
+    else {
+        return [n0, v1, a];
+    }
+};
+const reduceX = (ms) => ([i, n]) => (a) => {
+    const [m0, m2] = ms;
+    const f = m => {
+        const ra = m(a);
+        return n.length === 3 ? ra(n) : [...ra([n[0], n[1], n[2]]), n[3], n[4]];
+    };
+    switch (i) {
+        case 0: {
+            return f(m0);
+        }
+        case 2: {
+            return f(m2);
+        }
+        case 4: {
+            return [n[0], n[1], ...m2(a)([n[2], n[3], n[4]])];
+        }
+    }
+};
+const reduce = fold(reduceX([reduceValue0, reduceValue2]));
+const initReduce = reduceX([initValue0, initValue1]);
+export const nodeRemove = (c) => (node) => {
+    const f = () => {
+        const { first, tail } = find.find(c)(node);
+        const branch = n => f => {
+            const [v, p] = path(null)(n);
+            return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) };
+        };
+        const [i, n] = first;
+        switch (i) {
+            case 1: {
+                switch (n.length) {
+                    case 1: {
+                        return { first: null, tail };
+                    }
+                    case 2: {
+                        return { first: [n[1]], tail };
+                    }
+                    case 3: {
+                        return branch(n[2])(v => [2, [n[0], v, n[2]]]);
+                    }
+                    case 5: {
+                        return branch(n[2])(v => [2, [n[0], v, n[2], n[3], n[4]]]);
+                    }
+                }
+            }
+            case 3: {
+                switch (n.length) {
+                    case 2: {
+                        return { first: [n[0]], tail };
+                    }
+                    case 5: {
+                        return branch(n[4])(v => [4, [n[0], n[1], n[2], v, n[4]]]);
+                    }
+                }
+            }
+            default: {
+                return null;
+            }
+        }
+    };
+    const r = f();
+    if (r === null) {
+        return node;
+    }
+    const { first, tail } = r;
+    const tailR = next(tail);
+    if (tailR === null) {
+        return first;
+    }
+    const { first: tf, tail: tt } = tailR;
+    const result = reduce(initReduce(tf)(first))(tt);
+    return result.length === 1 ? result[0] : result;
+};
+export const remove = c => map(nodeRemove(c));

package/types/btree/remove/test.f.d.ts

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