functionalscript 0.3.8 → 0.3.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

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

@@ -1,4 +1,21 @@
-import * as compare from '../function/compare/module.f.ts';
+/**
+ * A collection of utility functions for working with `bigint` values.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { sum, abs, log2, bitLength, mask } from './module.f.ts'
+ *
+ * const total = sum([1n, 2n, 3n]) // 6n
+ * const absoluteValue = abs(-42n) // 42n
+ * const logValue = log2(8n) // 3n
+ * const bitCount = bitLength(255n) // 8n
+ * const bitmask = mask(5n) // 31n
+ * ```
+ */
+import { type Sign } from '../function/compare/module.f.ts';
 import type * as Operator from '../function/operator/module.f.ts';
 import { type List } from '../list/module.f.ts';
 export type Unary = Operator.Unary<bigint, bigint>;
@@ -6,7 +23,7 @@ export type Reduce = Operator.Reduce<bigint>;
 export declare const addition: Reduce;
 export declare const sum: (input: List<bigint>) => bigint;
 export declare const abs: Unary;
-export declare const sign: (a: bigint) => compare.Sign;
+export declare const sign: (a: bigint) => Sign;
 export declare const serialize: (a: bigint) => string;
 /**
  * Calculates the base-2 logarithm (floor).

package/types/bigint/module.f.js

@@ -1,5 +1,21 @@
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+/**
+ * A collection of utility functions for working with `bigint` values.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { sum, abs, log2, bitLength, mask } from './module.f.ts'
+ *
+ * const total = sum([1n, 2n, 3n]) // 6n
+ * const absoluteValue = abs(-42n) // 42n
+ * const logValue = log2(8n) // 3n
+ * const bitCount = bitLength(255n) // 8n
+ * const bitmask = mask(5n) // 31n
+ * ```
+ */
+import { unsafeCmp } from "../function/compare/module.f.js";
 import { reduce } from "../list/module.f.js";
 export const addition = a => b => a + b;
 export const sum = reduce(addition)(0n);
@@ -25,13 +41,11 @@ export const serialize = (a) => `${a}n`;
  *    determining the exact value of the logarithm.
  */
 export const log2 = (v) => {
-    // TODO: use step 32 and `Math.clz32()` at the end.
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
     if (v <= 0n) {
         return -1n;
     }
-    let result = 0n;
-    let i = 1n;
+    let result = 31n;
+    let i = 32n;
     while (true) {
         const n = v >> i;
         if (n === 0n) {
@@ -43,8 +57,8 @@ export const log2 = (v) => {
         i <<= 1n;
     }
     // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
-    // Because of this, We check if `i` is greater than 1 before we divide it by 2.
-    while (i !== 1n) {
+    // Because of this, We check if `i` is greater than 32 before we divide it by 2.
+    while (i !== 32n) {
         i >>= 1n;
         const n = v >> i;
         if (n !== 0n) {
@@ -52,7 +66,7 @@ export const log2 = (v) => {
             v = n;
         }
     }
-    return result;
+    return result - BigInt(Math.clz32(Number(v)));
 };
 /**
  * Calculates the bit length of a given BigInt.

package/types/bigint/test.f.d.ts

@@ -1,4 +1,11 @@
 declare const _default: {
+    example: () => void;
+    benchmark: {
+        str: () => void;
+        stringHexLog2: () => void;
+        oldLog2: () => void;
+        log2: () => void;
+    };
     mask: () => void;
     sum: () => void;
     abs: (() => void)[];

package/types/bigint/test.f.js

@@ -1,5 +1,79 @@
 import { sum, abs, serialize, log2, bitLength, mask } from "./module.f.js";
+const oldLog2 = (v) => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    let result = 0n;
+    let i = 1n;
+    while (true) {
+        const n = v >> i;
+        if (n === 0n) {
+            // overshot
+            break;
+        }
+        v = n;
+        result += i;
+        i <<= 1n; // multiple by two
+    }
+    // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
+    // Because of this, We check if `i` is greater than 1 before we divide it by 2.
+    while (i !== 1n) {
+        i >>= 1n;
+        const n = v >> i;
+        if (n !== 0n) {
+            result += i;
+            v = n;
+        }
+    }
+    return result;
+};
+const stringLog2 = (v) => BigInt(v.toString(2).length) - 1n;
+const stringHexLog2 = (v) => {
+    const len = (BigInt(v.toString(16).length) - 1n) << 2n;
+    const x = v >> len;
+    return len + 31n - BigInt(Math.clz32(Number(x)));
+};
+const benchmark = (f) => () => {
+    let e = 1048575n;
+    let c = 1n << e;
+    for (let i = 0n; i < 1_000; ++i) {
+        const x = f(c);
+        if (x !== e) {
+            throw x;
+        }
+        c >>= 1n;
+        --e;
+    }
+};
 export default {
+    example: () => {
+        const total = sum([1n, 2n, 3n]); // 6n
+        if (total !== 6n) {
+            throw total;
+        }
+        const absoluteValue = abs(-42n); // 42n
+        if (absoluteValue !== 42n) {
+            throw total;
+        }
+        const logValue = log2(8n); // 3n
+        if (logValue !== 3n) {
+            throw total;
+        }
+        const bitCount = bitLength(255n); // 8n
+        if (bitCount !== 8n) {
+            throw total;
+        }
+        const bitmask = mask(5n); // 31n
+        if (bitmask !== 31n) {
+            throw total;
+        }
+    },
+    benchmark: {
+        str: benchmark(stringLog2),
+        stringHexLog2: benchmark(stringHexLog2),
+        oldLog2: benchmark(oldLog2),
+        log2: benchmark(log2),
+    },
     mask: () => {
         const result = mask(3n); // 7n
         if (result !== 7n) {

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

@@ -1,20 +1,21 @@
-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>];
+import type { Leaf1, Leaf2, Branch3, Branch5, TNode } from '../types/module.f.ts';
+import type * as List from '../../list/module.f.ts';
+import { type Compare } from '../../function/compare/module.f.ts';
+import type { Index3, Index5 } from "../../array/module.f.ts";
+type FirstLeaf1<T> = readonly [Index3, Leaf1<T>];
+type FirstBranch3<T> = readonly [1, Branch3<T>];
+type FirstLeaf2<T> = readonly [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>];
+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 find: <T>(c: 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

@@ -1,8 +1,4 @@
-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";
+import { index3, index5 } from "../../function/compare/module.f.js";
 const child = (item) => item[1][item[0]];
 export const find = (c) => {
     const i3 = index3(c);

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

@@ -2,8 +2,7 @@ import * as _ from "./module.f.js";
 import * as list from "../../list/module.f.js";
 import * as json from "../../../json/module.f.js";
 import { sort } from "../../object/module.f.js";
-import * as string from "../../string/module.f.js";
-const { cmp } = string;
+import { cmp } from "../../string/module.f.js";
 import * as s from "../set/module.f.js";
 const jsonStr = json.stringify(sort);
 const set = node => value => s.set(cmp(value))(() => value)(node);

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

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

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

@@ -1,4 +1,4 @@
-import * as _ from '../types/module.f.ts';
-import * as Cmp from '../../function/compare/module.f.ts';
+import type * as _ from '../types/module.f.ts';
+import type * 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

@@ -1,9 +1,6 @@
-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 => {

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

@@ -1,10 +1,8 @@
 import * as _ from "./module.f.js";
 import * as s from "../set/module.f.js";
-import * as str from "../../string/module.f.js";
-const { cmp } = str;
+import { cmp } from "../../string/module.f.js";
 import * as json from "../../../json/module.f.js";
-import * as o from "../../object/module.f.js";
-const { sort } = o;
+import { sort } from "../../object/module.f.js";
 const set = (node) => (value) => s.set(cmp(value))(() => value)(node);
 const remove = (node) => (value) => _.nodeRemove(cmp(value))(node);
 const jsonStr = json.stringify(sort);

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

@@ -1,3 +1,3 @@
-import * as _ from '../types/module.f.ts';
-import * as Cmp from '../../function/compare/module.f.ts';
+import type * as _ from '../types/module.f.ts';
+import type * as Cmp from '../../function/compare/module.f.ts';
 export declare const set: <T>(c: Cmp.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.TNode<T>;

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

@@ -1,9 +1,5 @@
-import * as _ from "../types/module.f.js";
-import * as btreeFind from "../find/module.f.js";
-const { find } = btreeFind;
-import * as Cmp from "../../function/compare/module.f.js";
-import * as list from "../../list/module.f.js";
-const { fold } = list;
+import { find } from "../find/module.f.js";
+import { fold } from "../../list/module.f.js";
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]];
 const reduceOp = ([i, x]) => a => {
     switch (i) {

package/types/btree/test.f.js

@@ -1,15 +1,12 @@
-import * as _ from "./module.f.js";
-const { values } = _;
+import { values } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../object/module.f.js";
-const { sort } = o;
-import * as str from "../string/module.f.js";
-const { cmp } = str;
-import * as list from "../list/module.f.js";
+import { sort } from "../object/module.f.js";
+import { cmp } from "../string/module.f.js";
+import { next, toArray } from "../list/module.f.js";
 import * as s from "./set/module.f.js";
 import * as f from "./find/module.f.js";
 const jsonStr = json.stringify(sort);
-const stringify = sequence => jsonStr(list.toArray(sequence));
+const stringify = sequence => jsonStr(toArray(sequence));
 const set = node => value => s.set(cmp(value))(() => value)(node);
 const valueTest1 = () => {
     let _map = ['a'];
@@ -18,7 +15,7 @@ const valueTest1 = () => {
     _map = set(_map)('d');
     _map = set(_map)('e');
     _map = set(_map)('f');
-    let result = stringify(values(_map));
+    const result = stringify(values(_map));
     if (result !== '["a","b","c","d","e","f"]') {
         throw result;
     }
@@ -27,7 +24,7 @@ const valuesTest2 = () => {
     let _map = ['1'];
     for (let i = 2; i <= 10; i++)
         _map = set(_map)((i * i).toString());
-    let result = stringify(values(_map));
+    const result = stringify(values(_map));
     if (result !== '["1","100","16","25","36","4","49","64","81","9"]') {
         throw result;
     }
@@ -59,9 +56,9 @@ const test = () => {
     _map = set(_map)('f');
     //
     {
-        let _item = list.next(values(_map));
+        let _item = next(values(_map));
         while (_item !== null) {
-            _item = list.next(_item.tail);
+            _item = next(_item.tail);
         }
     }
 };

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

@@ -1,6 +1,4 @@
-export type Array1<T> = readonly [T];
-export type Array2<T> = readonly [T, T];
-export type Array3<T> = readonly [T, T, T];
+import type { Array1, Array2 } from '../../array/module.f.ts';
 export type Leaf1<T> = Array1<T>;
 export type Leaf2<T> = Array2<T>;
 export type Branch3<T> = readonly [TNode<T>, T, TNode<T>];

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

@@ -1,5 +1,5 @@
-import type * as RangeMap from '../range_map/module.f.ts';
-import type * as SortedSet from '../sorted_set/module.f.ts';
+import type { RangeMap } from '../range_map/module.f.ts';
+import type { SortedSet } from '../sorted_set/module.f.ts';
 export type ByteSet = bigint;
 type Byte = number;
 export declare const has: (n: Byte) => (s: ByteSet) => boolean;
@@ -12,5 +12,5 @@ export declare const complement: (n: ByteSet) => ByteSet;
 export declare const set: (_: number) => (b: ByteSet) => ByteSet;
 export declare const setRange: (_: readonly [number, number]) => (b: ByteSet) => ByteSet;
 export declare const unset: (n: Byte) => (s: ByteSet) => ByteSet;
-export declare const toRangeMap: (n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>;
+export declare const toRangeMap: (n: ByteSet) => (s: string) => RangeMap<SortedSet<string>>;
 export {};

package/types/byte_set/module.f.js

@@ -1,6 +1,5 @@
 import { compose } from "../function/module.f.js";
-import * as list from "../list/module.f.js";
-const { reverse, countdown, flat, map } = list;
+import { reverse, countdown, flat, map } from "../list/module.f.js";
 export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;
 // create a set
 export const empty = 0n;

package/types/byte_set/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
-import * as list from "../list/module.f.js";
-const { every, countdown, map, toArray } = list;
+import { every, countdown, map, toArray } 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 { sort } from "../object/module.f.js";
 const stringify = json.stringify(sort);
 export default {
     has: [

package/types/function/compare/module.f.d.ts

@@ -1,10 +1,6 @@
-import type * as Array from '../../array/module.f.ts';
-export type Index3 = Array.Index3;
-export type Index5 = Array.Index5;
-type Array2<T> = Array.Array2<T>;
+import type { Index3, Index5, Array2 } from '../../array/module.f.ts';
 export type Sign = -1 | 0 | 1;
 export type Compare<T> = (_: T) => Sign;
 export declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
 export declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
 export declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
-export {};

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

@@ -1,12 +1,10 @@
-import type * as BtreeTypes from '../btree/types/module.f.ts';
-import type * as Compare from '../function/compare/module.f.ts';
+import type { Tree } from '../btree/types/module.f.ts';
 import { type List } from '../list/module.f.ts';
-import type * as Operator from '../function/operator/module.f.ts';
-export type Sign = Compare.Sign;
+import type { Reduce } from '../function/operator/module.f.ts';
 export type Entry<T> = readonly [string, T];
-export type Map<T> = BtreeTypes.Tree<Entry<T>>;
+export type Map<T> = Tree<Entry<T>>;
 export declare const at: (name: string) => <T>(map: Map<T>) => T | null;
-export declare const setReduce: <T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
+export declare const setReduce: <T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
 export declare const setReplace: (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>;
 export declare const entries: <T>(map: Map<T>) => List<Entry<T>>;
 export declare const fromEntries: <T>(entries: List<Entry<T>>) => Map<T>;

package/types/map/test.f.js

@@ -1,5 +1,5 @@
 import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
-import * as seq from "../list/module.f.js";
+import { toArray } from "../list/module.f.js";
 export default {
     main: [
         () => {
@@ -90,7 +90,7 @@ export default {
             if (at('a')(m) !== null) {
                 throw 'error';
             }
-            const e = seq.toArray(entries(m));
+            const e = toArray(entries(m));
             if (e.length !== 2) {
                 throw 'error';
             }

package/types/nibble_set/test.f.js

@@ -1,87 +1,87 @@
 import { every, map, countdown } from "../list/module.f.js";
-import * as _ from "./module.f.js";
+import { empty, has, set, setRange, unset, universe, complement } from "./module.f.js";
 export default {
     has: () => {
-        if (_.has(0)(_.empty)) {
-            throw _.empty;
+        if (has(0)(empty)) {
+            throw empty;
         }
-        if (_.has(1)(_.empty)) {
-            throw _.empty;
+        if (has(1)(empty)) {
+            throw empty;
         }
-        if (_.has(15)(_.empty)) {
-            throw _.empty;
+        if (has(15)(empty)) {
+            throw empty;
         }
     },
     set: [
         () => {
-            const s = _.set(0)(_.empty);
+            const s = set(0)(empty);
             if (s !== 1) {
                 throw s;
             }
-            if (!_.has(0)(s)) {
+            if (!has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (_.has(15)(s)) {
+            if (has(15)(s)) {
                 throw s;
             }
         },
         () => {
-            const s = _.set(15)(_.empty);
+            const s = set(15)(empty);
             if (s !== 0x8000) {
                 throw s;
             }
-            if (_.has(0)(s)) {
+            if (has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (!_.has(15)(s)) {
+            if (!has(15)(s)) {
                 throw s;
             }
         }
     ],
     unset: () => [
         () => {
-            const a = _.set(0)(_.empty);
-            const result = _.unset(0)(a);
+            const a = set(0)(empty);
+            const result = unset(0)(a);
             if (result !== 0) {
                 throw result;
             }
         },
         () => {
-            const a = _.set(15)(_.empty);
-            const result = _.unset(15)(a);
+            const a = set(15)(empty);
+            const result = unset(15)(a);
             if (result !== 0) {
                 throw result;
             }
         }
     ],
     setRange: () => {
-        const result = _.setRange([2, 5])(_.empty);
+        const result = setRange([2, 5])(empty);
         if (result !== 60) {
             throw result;
         }
     },
     universe: () => {
-        const x = every(map((v) => _.has(v)(_.universe))(countdown(16)));
+        const x = every(map((v) => has(v)(universe))(countdown(16)));
         if (!x) {
             throw x;
         }
     },
     compliment: {
         empty: () => {
-            const r = _.complement(_.empty);
-            if (r !== _.universe) {
+            const r = complement(empty);
+            if (r !== universe) {
                 throw r;
             }
         },
         universe: () => {
-            const r = _.complement(_.universe);
-            if (r !== _.empty) {
+            const r = complement(universe);
+            if (r !== empty) {
                 throw r;
             }
         },

package/types/nullable/test.f.js

@@ -1,6 +1,6 @@
-import * as _ from "./module.f.js";
+import { map } from "./module.f.js";
 export default () => {
-    const optionSq = _.map((v) => v * v);
+    const optionSq = map((v) => v * v);
     const sq3 = optionSq(3);
     if (sq3 !== 9) {
         throw sq3;

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

@@ -1,6 +1,6 @@
 import { type List } from '../list/module.f.ts';
-import * as compare from '../function/compare/module.f.ts';
+import { type Sign } from '../function/compare/module.f.ts';
 export declare const sum: (input: List<number>) => number;
 export declare const min: (input: List<number>) => number | null;
 export declare const max: (input: List<number>) => number | null;
-export declare const cmp: (a: number) => (b: number) => compare.Sign;
+export declare const cmp: (a: number) => (b: number) => Sign;

package/types/number/module.f.js

@@ -1,7 +1,6 @@
 import { reduce } from "../list/module.f.js";
 import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 export const sum = reduce(addition)(0);
 export const min = reduce(minOp)(null);
 export const max = reduce(maxOp)(null);

package/types/object/test.f.js

@@ -1,15 +1,15 @@
-import * as _ from "./module.f.js";
+import { at } from "./module.f.js";
 export default {
     ctor: () => {
         const a = {};
-        const value = _.at('constructor')(a);
+        const value = at('constructor')(a);
         if (value !== null) {
             throw value;
         }
     },
     property: () => {
         const a = { constructor: 42 };
-        const value = _.at('constructor')(a);
+        const value = at('constructor')(a);
         if (value !== 42) {
             throw value;
         }

package/types/range/test.f.js

@@ -1,18 +1,18 @@
-import * as _ from "./module.f.js";
+import { contains } from "./module.f.js";
 export default () => {
-    if (!_.contains([0, 5])(1)) {
+    if (!contains([0, 5])(1)) {
         throw 1;
     }
-    if (!_.contains([0, 5])(0)) {
+    if (!contains([0, 5])(0)) {
         throw 0;
     }
-    if (!_.contains([0, 5])(5)) {
+    if (!contains([0, 5])(5)) {
         throw 5;
     }
-    if (_.contains([0, 5])(-1)) {
+    if (contains([0, 5])(-1)) {
         throw -1;
     }
-    if (_.contains([0, 5])(6)) {
+    if (contains([0, 5])(6)) {
         throw 6;
     }
 };

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

@@ -1,14 +1,14 @@
 import { type SortedList } from '../sorted_list/module.f.ts';
-import type * as O from '../function/operator/module.f.ts';
-import type * as Range from '../range/module.f.ts';
+import type { Reduce, Equal } from '../function/operator/module.f.ts';
+import type { Range } from '../range/module.f.ts';
 export type Entry<T> = [T, number];
 export type RangeMap<T> = SortedList<Entry<T>>;
 export type RangeMapArray<T> = readonly Entry<T>[];
 export type Operators<T> = {
-    readonly union: O.Reduce<T>;
-    readonly equal: O.Equal<T>;
+    readonly union: Reduce<T>;
+    readonly equal: Equal<T>;
 };
-export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
+export type RangeMerge<T> = Reduce<RangeMap<T>>;
 export declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
 export declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
-export declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
+export declare const fromRange: <T>(def: T) => (r: Range) => (value: T) => RangeMapArray<T>;

package/types/range_map/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
-import * as object from "../object/module.f.js";
-const { sort } = object;
+import { sort } from "../object/module.f.js";
 import * as sortedSet from "../sorted_set/module.f.js";
 import * as list from "../list/module.f.js";
 import * as operator from "../function/operator/module.f.js";

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

@@ -1,10 +1,10 @@
-import type * as compare from '../function/compare/module.f.ts';
+import type { Sign } from '../function/compare/module.f.ts';
 import { type List } from '../list/module.f.ts';
-import type * as option from '../nullable/module.f.ts';
+import type { Nullable } from '../nullable/module.f.ts';
 export type SortedList<T> = List<T>;
 type SortedArray<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => compare.Sign;
-export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [option.Nullable<T>, compare.Sign, S];
+type Cmp<T> = (a: T) => (b: T) => Sign;
+export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [Nullable<T>, Sign, S];
 export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
 type MergeReduce<T, S> = {
     readonly reduceOp: ReduceOp<T, S>;

package/types/sorted_list/test.f.js

@@ -1,4 +1,4 @@
-import * as _ from "./module.f.js";
+import { find, merge } from "./module.f.js";
 import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
@@ -9,13 +9,13 @@ const reverseCmp = flip(unsafeCmp);
 export default {
     sortedMergre: [
         () => {
-            const result = stringify(toArray(_.merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            const result = stringify(toArray(merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
             if (result !== '[1,2,3,4,5]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(_.merge(unsafeCmp)([1, 2, 3])([])));
+            const result = stringify(toArray(merge(unsafeCmp)([1, 2, 3])([])));
             if (result !== '[1,2,3]') {
                 throw result;
             }
@@ -23,7 +23,7 @@ export default {
         () => {
             const n = 10_000;
             const list = countdown(n);
-            const result = _.merge(reverseCmp)(list)(list);
+            const result = merge(reverseCmp)(list)(list);
             const len = length(result);
             if (len != n) {
                 throw result;
@@ -32,25 +32,25 @@ export default {
     ],
     find: [
         () => {
-            const result = _.find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== 0) {
                 throw result;
             }
         },
         () => {
-            const result = _.find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== null) {
                 throw result;
             }
         },
         () => {
-            const result = _.find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== null) {
                 throw result;
             }
         },
         () => {
-            const result = _.find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== 80) {
                 throw result;
             }

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

@@ -1,6 +1,6 @@
-import type * as Compare from '../function/compare/module.f.ts';
+import type { Sign } from '../function/compare/module.f.ts';
 export type SortedSet<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
+type Cmp<T> = (a: T) => (b: T) => Sign;
 export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;

package/types/sorted_set/test.f.js

@@ -1,4 +1,4 @@
-import * as _ from "./module.f.js";
+import { has, intersect, union } from "./module.f.js";
 import { unsafeCmp } from "../function/compare/module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
@@ -9,13 +9,13 @@ const reverseCmp = flip(unsafeCmp);
 export default {
     union: [
         () => {
-            const result = stringify(toArray(_.union(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            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])([])));
+            const result = stringify(toArray(union(unsafeCmp)([1, 2, 3])([])));
             if (result !== '[1,2,3]') {
                 throw result;
             }
@@ -23,7 +23,7 @@ export default {
         () => {
             const n = 10_000;
             const sortedSet = toArray(countdown(n));
-            const result = _.union(reverseCmp)(sortedSet)(sortedSet);
+            const result = union(reverseCmp)(sortedSet)(sortedSet);
             const len = length(result);
             if (len != n) {
                 throw result;
@@ -32,13 +32,13 @@ export default {
     ],
     intersect: [
         () => {
-            const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            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])([])));
+            const result = stringify(toArray(intersect(unsafeCmp)([1, 2, 3])([])));
             if (result !== '[]') {
                 throw result;
             }
@@ -46,25 +46,25 @@ export default {
     ],
     has: [
         () => {
-            const result = _.has(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            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]);
+            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]);
+            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]);
+            const result = has(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (!result) {
                 throw result;
             }

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

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

package/types/string/module.f.js

@@ -1,7 +1,6 @@
 import { reduce as listReduce, repeat as listRepeat } from "../list/module.f.js";
 import { compose } from "../function/module.f.js";
-import * as compare from "../function/compare/module.f.js";
-const { unsafeCmp } = compare;
+import { unsafeCmp } from "../function/compare/module.f.js";
 import { join as joinOp, concat as concatOp } from "../function/operator/module.f.js";
 const reduce = o => listReduce(o)('');
 export const join = compose(joinOp)(reduce);

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

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

package/types/string_set/test.f.js

@@ -1,63 +1,63 @@
-import * as _ from "./module.f.js";
+import { contains, remove, set } from "./module.f.js";
 export default {
     contains: () => {
-        const r = _.set('hello')(null);
-        if (!_.contains('hello')(r)) {
+        const r = set('hello')(null);
+        if (!contains('hello')(r)) {
             throw r;
         }
-        if (_.contains('hello1')(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)) {
+        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)) {
+        if (contains('hello1')(r)) {
             throw r;
         }
-        if (!_.contains('HELLO')(r)) {
+        if (!contains('HELLO')(r)) {
             throw r;
         }
-        if (_.contains('WORLD')(r)) {
+        if (contains('WORLD')(r)) {
             throw r;
         }
-        if (!_.contains('world')(r)) {
+        if (!contains('world')(r)) {
             throw r;
         }
-        if (_.contains('world!')(r)) {
+        if (contains('world!')(r)) {
             throw r;
         }
-        if (!_.contains('WORLD!')(r)) {
+        if (!contains('WORLD!')(r)) {
             throw r;
         }
         //
-        r = _.remove('hello')(r);
-        if (_.contains('hello')(r)) {
+        r = remove('hello')(r);
+        if (contains('hello')(r)) {
             throw r;
         }
-        if (!_.contains('world')(r)) {
+        if (!contains('world')(r)) {
             throw r;
         }
-        r = _.remove('world')(r);
-        if (_.contains('world')(r)) {
+        r = remove('world')(r);
+        if (contains('world')(r)) {
             throw r;
         }
-        if (!_.contains('HELLO')(r)) {
+        if (!contains('HELLO')(r)) {
             throw r;
         }
-        r = _.remove('HELLO')(r);
-        if (_.contains('HELLO')(r)) {
+        r = remove('HELLO')(r);
+        if (contains('HELLO')(r)) {
             throw r;
         }
-        if (!_.contains('WORLD!')(r)) {
+        if (!contains('WORLD!')(r)) {
             throw r;
         }
-        r = _.remove('WORLD!')(r);
+        r = remove('WORLD!')(r);
         if (r !== null) {
             throw r;
         }