functionalscript 0.3.10 → 0.3.11

package/README.md

@@ -15,6 +15,7 @@ FunctionalScript is a safe, purely functional programming language and a strict
 [A working draft of the FunctionalScript specification](./issues/lang/README.md).
 
 Learn more about
+
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 

package/crypto/prime_field/module.f.d.ts

@@ -1,6 +1,4 @@
-import type * as Operator from '../../types/function/operator/module.f.ts';
-type Reduce = Operator.Reduce<bigint>;
-type Unary = Operator.Unary<bigint, bigint>;
+import type { Unary, Reduce } from '../../types/bigint/module.f.ts';
 /**
  * A type representing a prime field and its associated operations.
  */
@@ -40,4 +38,3 @@ export declare const prime_field: (p: bigint) => PrimeField;
  * ```
  */
 export declare const sqrt: ({ p, mul, pow }: PrimeField) => (a: bigint) => bigint | null;
-export {};

package/crypto/secp/module.f.d.ts

@@ -1,4 +1,4 @@
-import type * as Operator from '../../types/function/operator/module.f.ts';
+import type { Reduce } from '../../types/function/operator/module.f.ts';
 import { type PrimeField } from '../prime_field/module.f.ts';
 /**
  * A 2D point represented as a pair of `bigint` values `[x, y]`.
@@ -27,7 +27,7 @@ type Curve = {
     readonly y2: (x: bigint) => bigint;
     readonly y: (x: bigint) => bigint | null;
     readonly neg: (a: Point) => Point;
-    readonly add: Operator.Reduce<Point>;
+    readonly add: Reduce<Point>;
     readonly mul: (a: Point) => (n: bigint) => Point;
 };
 /**

package/fsc/module.f.js

@@ -1,15 +1,13 @@
-import * as operator from "../types/function/operator/module.f.js";
+import { strictEqual } from "../types/function/operator/module.f.js";
 import { merge as rangeMapMerge, fromRange, get, } from "../types/range_map/module.f.js";
-import * as list from "../types/list/module.f.js";
-const { reduce: listReduce } = list;
+import { reduce as listReduce, toArray, map } from "../types/list/module.f.js";
 import { range as asciiRange } from "../text/ascii/module.f.js";
 import { fn } from "../types/function/module.f.js";
 import { one } from "../types/range/module.f.js";
-const { toArray, map } = list;
 const fromCharCode = String.fromCharCode;
 const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol];
 const def = () => unexpectedSymbol;
-const union = a => b => {
+const union = (a) => (b) => {
     if (a === def || a === b) {
         return b;
     }
@@ -22,7 +20,7 @@ const empty = [];
 const reduce = (a) => {
     const merge = rangeMapMerge({
         union,
-        equal: operator.strictEqual,
+        equal: strictEqual,
     });
     return toArray(listReduce(merge)(empty)(a));
 };

package/fsm/module.f.d.ts

@@ -1,13 +1,13 @@
-import * as list from '../types/list/module.f.ts';
-import * as byteSet from '../types/byte_set/module.f.ts';
-import * as rangeMap from '../types/range_map/module.f.ts';
-type Rule = readonly [string, byteSet.ByteSet, string];
-export type Grammar = list.List<Rule>;
+import { type List } from '../types/list/module.f.ts';
+import { type ByteSet } from '../types/byte_set/module.f.ts';
+import { type RangeMapArray } from '../types/range_map/module.f.ts';
+type Rule = readonly [string, ByteSet, string];
+export type Grammar = List<Rule>;
 type Dfa = {
-    readonly [state in string]: rangeMap.RangeMapArray<string>;
+    readonly [state in string]: RangeMapArray<string>;
 };
-export declare const toRange: (s: string) => byteSet.ByteSet;
-export declare const toUnion: (s: string) => byteSet.ByteSet;
+export declare const toRange: (s: string) => ByteSet;
+export declare const toUnion: (s: string) => ByteSet;
 export declare const dfa: (grammar: Grammar) => Dfa;
-export declare const run: (dfa: Dfa) => (input: list.List<number>) => list.List<string>;
+export declare const run: (dfa: Dfa) => (input: List<number>) => List<string>;
 export {};

package/fsm/module.f.js

@@ -1,25 +1,16 @@
-import * as list from "../types/list/module.f.js";
-const { equal, isEmpty, fold, toArray, scan, foldScan, empty: emptyList } = list;
-import * as byteSet from "../types/byte_set/module.f.js";
-const { toRangeMap, union: byteSetUnion, one, empty } = byteSet;
-import * as sortedSet from "../types/sorted_set/module.f.js";
-const { intersect, union: sortedSetUnion } = sortedSet;
-import * as rangeMap from "../types/range_map/module.f.js";
-const { merge } = rangeMap;
-import * as cmp from "../types/function/compare/module.f.js";
-const { unsafeCmp } = cmp;
-import * as operator from "../types/function/operator/module.f.js";
-const { strictEqual } = operator;
-import * as j from "../json/module.f.js";
-const { stringify } = j;
-import * as f from "../types/function/module.f.js";
-const { identity } = f;
-import * as utf16 from "../text/utf16/module.f.js";
-const { stringToList } = utf16;
+import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from "../types/list/module.f.js";
+import { toRangeMap, union as byteSetUnion, one, empty, range } from "../types/byte_set/module.f.js";
+import { intersect, union as sortedSetUnion } from "../types/sorted_set/module.f.js";
+import { merge, get as rangeMapGet } from "../types/range_map/module.f.js";
+import { unsafeCmp } from "../types/function/compare/module.f.js";
+import { strictEqual } from "../types/function/operator/module.f.js";
+import { stringify } from "../json/module.f.js";
+import { identity } from "../types/function/module.f.js";
+import { stringToList } from "../text/utf16/module.f.js";
 const stringifyIdentity = stringify(identity);
 export const toRange = s => {
     const [b, e] = toArray(stringToList(s));
-    return byteSet.range([b, e]);
+    return range([b, e]);
 };
 const toUnionOp = i => bs => byteSetUnion(bs)(one(i));
 export const toUnion = s => {
@@ -54,6 +45,6 @@ const emptyStateStringify = stringifyIdentity(emptyState);
 const initialState = [''];
 const initialStateStringify = stringifyIdentity(initialState);
 export const dfa = grammar => addEntry(grammar)(initialState)({});
-const get = rangeMap.get(emptyStateStringify);
+const get = rangeMapGet(emptyStateStringify);
 const runOp = dfa => input => s => get(input)(dfa[s]);
-export const run = dfa => input => foldScan(runOp(dfa))(initialStateStringify)(input);
+export const run = (dfa) => (input) => foldScan(runOp(dfa))(initialStateStringify)(input);

package/html/module.f.js

@@ -1,8 +1,7 @@
 import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f.js";
 import { concat as stringConcat } from "../types/string/module.f.js";
 import { compose } from "../types/function/module.f.js";
-import * as utf16 from "../text/utf16/module.f.js";
-const { stringToList } = utf16;
+import { stringToList } from "../text/utf16/module.f.js";
 const { fromCharCode } = String;
 const { entries } = Object;
 /**

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

@@ -1,4 +1,4 @@
-export type Buffer = {};
+export type Buffer = object;
 type Fs<T> = {
     readonly readFileSync: (name: string) => Buffer;
     readonly writeFileSync: (name: string, content: string) => T;

package/package.json

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

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

@@ -1,5 +1,5 @@
 import type { Leaf1, Leaf2, Branch3, Branch5, TNode } from '../types/module.f.ts';
-import type * as List from '../../list/module.f.ts';
+import type { 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>];
@@ -10,7 +10,7 @@ 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 Path<T> = List<PathItem<T>>;
 export type Result<T> = {
     readonly first: First<T>;
     readonly tail: Path<T>;

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

@@ -1,4 +1,4 @@
-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>;
+import type { TNode, Tree } from '../types/module.f.ts';
+import type { Compare } from '../../function/compare/module.f.ts';
+export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
+export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;

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

@@ -1,9 +1,7 @@
-import * as find from "../find/module.f.js";
-import * as list from "../../list/module.f.js";
-const { fold, concat, next } = list;
-import * as n from "../../nullable/module.f.js";
-const { map } = n;
-const path = tail => n => {
+import { find } from "../find/module.f.js";
+import { fold, concat, next } from "../../list/module.f.js";
+import { map } from "../../nullable/module.f.js";
+const path = (tail) => (n) => {
     switch (n.length) {
         case 1: {
             return [n[0], { first: null, tail }];
@@ -19,7 +17,7 @@ const path = tail => n => {
         }
     }
 };
-const reduceValue0 = a => n => {
+const reduceValue0 = (a) => (n) => {
     const [, v1, n2] = n;
     if (a.length === 1) {
         switch (n2.length) {
@@ -38,7 +36,7 @@ const reduceValue0 = a => n => {
         return [a, v1, n2];
     }
 };
-const reduceValue2 = a => n => {
+const reduceValue2 = (a) => (n) => {
     const [n0, v1,] = n;
     if (a.length === 1) {
         switch (n0.length) {
@@ -57,7 +55,7 @@ const reduceValue2 = a => n => {
         return [n0, v1, a];
     }
 };
-const initValue0 = a => n => {
+const initValue0 = (a) => (n) => {
     const [, v1, n2] = n;
     if (a === null) {
         switch (n2.length) {
@@ -76,7 +74,7 @@ const initValue0 = a => n => {
         return [a, v1, n2];
     }
 };
-const initValue1 = a => n => {
+const initValue1 = (a) => (n) => {
     const [n0, v1] = n;
     if (a === null) {
         switch (n0.length) {
@@ -117,7 +115,7 @@ 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 { first, tail } = 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 }) };

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

@@ -1,10 +1,10 @@
-import * as _ from "./module.f.js";
+import { nodeRemove } from "./module.f.js";
 import * as s from "../set/module.f.js";
 import { cmp } from "../../string/module.f.js";
 import * as json from "../../../json/module.f.js";
 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 remove = (node) => (value) => nodeRemove(cmp(value))(node);
 const jsonStr = json.stringify(sort);
 const test = () => {
     let _map = ['1'];

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

@@ -1,3 +1,3 @@
-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>;
+import type { TNode, Tree } from '../types/module.f.ts';
+import type { Compare } from '../../function/compare/module.f.ts';
+export declare const set: <T>(c: Compare<T>) => (f: (value: T | null) => T) => (tree: Tree<T>) => TNode<T>;

package/types/byte_set/test.f.js

@@ -1,4 +1,4 @@
-import * as _ from "./module.f.js";
+import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from "./module.f.js";
 import { every, countdown, map, toArray } from "../list/module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
@@ -6,112 +6,112 @@ const stringify = json.stringify(sort);
 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(33)(_.empty)) {
-                throw _.empty;
+            if (has(33)(empty)) {
+                throw empty;
             }
         },
         () => {
-            const s = _.set(0)(_.empty);
+            const s = set(0)(empty);
             if (s !== 1n) {
                 throw s;
             }
-            if (!_.has(0)(s)) {
+            if (!has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (_.has(33)(s)) {
+            if (has(33)(s)) {
                 throw s;
             }
         },
         () => {
-            const s = _.set(33)(_.empty);
+            const s = set(33)(empty);
             if (s !== 8589934592n) {
                 throw s;
             }
-            if (_.has(0)(s)) {
+            if (has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (!_.has(33)(s)) {
+            if (!has(33)(s)) {
                 throw s;
             }
         }
     ],
     setRange: () => {
-        const result = _.setRange([2, 5])(_.empty);
+        const result = setRange([2, 5])(empty);
         if (result !== 60n) {
             throw result;
         }
     },
     unset: [
         () => {
-            const a = _.set(0)(_.empty);
-            const result = _.unset(0)(a);
+            const a = set(0)(empty);
+            const result = unset(0)(a);
             if (result !== 0n) {
                 throw result;
             }
         },
         () => {
-            const a = _.set(255)(_.empty);
-            const result = _.unset(255)(a);
+            const a = set(255)(empty);
+            const result = unset(255)(a);
             if (result !== 0n) {
                 throw result;
             }
         }
     ],
     universe: () => {
-        const x = every(map((v) => _.has(v)(_.universe))(countdown(256)));
+        const x = every(map((v) => has(v)(universe))(countdown(256)));
         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;
             }
         },
     },
     toRangeMap: [
         () => {
-            const result = stringify(toArray(_.toRangeMap(_.empty)('a')));
+            const result = stringify(toArray(toRangeMap(empty)('a')));
             if (result !== '[]') {
                 throw result;
             }
         },
         () => {
-            const s = _.set(0)(_.empty);
-            const result = stringify(toArray(_.toRangeMap(s)('a')));
+            const s = set(0)(empty);
+            const result = stringify(toArray(toRangeMap(s)('a')));
             if (result !== '[[["a"],0]]') {
                 throw result;
             }
         },
         () => {
-            const s = _.setRange([1, 2])(_.empty);
-            const result = stringify(toArray(_.toRangeMap(s)('a')));
+            const s = setRange([1, 2])(empty);
+            const result = stringify(toArray(toRangeMap(s)('a')));
             if (result !== '[[[],0],[["a"],2]]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(_.toRangeMap(_.universe)('a')));
+            const result = stringify(toArray(toRangeMap(universe)('a')));
             if (result !== '[[["a"],255]]') {
                 throw result;
             }

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

@@ -1,7 +1,7 @@
 /**
  * A generic function type.
  */
-type Func<I, O> = (_: I) => O;
+export type Func<I, O> = (_: I) => O;
 /**
  * A postfix compose function.
  */

package/types/range_map/test.f.js

@@ -1,4 +1,4 @@
-import * as _ from "./module.f.js";
+import { get, merge, fromRange } 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";
@@ -12,7 +12,7 @@ export default {
         () => {
             const a = [[['a'], 1], [['b'], 2]];
             const b = null;
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
@@ -21,7 +21,7 @@ export default {
         () => {
             const a = null;
             const b = [[['a'], 1], [['b'], 2]];
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
@@ -30,7 +30,7 @@ export default {
         () => {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['a'], 1], [['b'], 2]];
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
@@ -39,7 +39,7 @@ export default {
         () => {
             const a = [[['a'], 1], [['c'], 3]];
             const b = [[['b'], 2], [['d'], 4]];
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') {
                 throw result;
@@ -48,7 +48,7 @@ export default {
         () => {
             const a = [[['a'], 1], [['d'], 4]];
             const b = [[['b'], 2], [['c'], 3]];
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') {
                 throw result;
@@ -57,7 +57,7 @@ export default {
         () => {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['b'], 1], [['a'], 2]];
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a","b"],2]]') {
                 throw result;
@@ -66,7 +66,7 @@ export default {
         () => {
             const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
             const b = [[['a'], 5]];
-            const merged = _.merge(op)(a)(b);
+            const merged = merge(op)(a)(b);
             const result = stringify(list.toArray(merged));
             if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') {
                 throw result;
@@ -75,60 +75,60 @@ export default {
     ],
     get: () => {
         const sortedSetEmpty = [];
-        const get = _.get(sortedSetEmpty);
+        const at = get(sortedSetEmpty);
         return [
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(5)(rm));
+                const result = stringify(at(5)(rm));
                 if (result !== '["a"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(10)(rm));
+                const result = stringify(at(10)(rm));
                 if (result !== '["a"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(15)(rm));
+                const result = stringify(at(15)(rm));
                 if (result !== '["b"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(20)(rm));
+                const result = stringify(at(20)(rm));
                 if (result !== '["b"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(25)(rm));
+                const result = stringify(at(25)(rm));
                 if (result !== '["c"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(30)(rm));
+                const result = stringify(at(30)(rm));
                 if (result !== '["c"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(get(35)(rm));
+                const result = stringify(at(35)(rm));
                 if (result !== '[]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [];
-                const result = stringify(get(10)(rm));
+                const result = stringify(at(10)(rm));
                 if (result !== '[]') {
                     throw result;
                 }
@@ -137,34 +137,34 @@ export default {
     },
     fromRange: () => {
         const def = -1;
-        const rm = _.fromRange(def)([1, 7])(42);
+        const rm = fromRange(def)([1, 7])(42);
         return [
             () => {
-                const result = _.get(def)(0)(rm);
+                const result = get(def)(0)(rm);
                 if (result !== -1) {
                     throw result;
                 }
             },
             () => {
-                const result = _.get(def)(1)(rm);
+                const result = get(def)(1)(rm);
                 if (result !== 42) {
                     throw result;
                 }
             },
             () => {
-                const result = _.get(def)(3)(rm);
+                const result = get(def)(3)(rm);
                 if (result !== 42) {
                     throw result;
                 }
             },
             () => {
-                const result = _.get(def)(7)(rm);
+                const result = get(def)(7)(rm);
                 if (result !== 42) {
                     throw result;
                 }
             },
             () => {
-                const result = _.get(def)(9)(rm);
+                const result = get(def)(9)(rm);
                 if (result !== -1) {
                     throw result;
                 }

package/types/sorted_list/module.f.js

@@ -1,7 +1,7 @@
 import { next } from "../list/module.f.js";
 import { identity } from "../function/module.f.js";
 export const genericMerge = ({ reduceOp, tailReduce }) => {
-    const f = state => a => b => () => {
+    const f = (state) => (a) => (b) => () => {
         const aResult = next(a);
         if (aResult === null) {
             return tailReduce(state)(b);
@@ -22,12 +22,12 @@ export const merge = (cmp) => {
     const tailReduce = mergeTail;
     return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null);
 };
-const cmpReduce = cmp => () => a => b => {
+const cmpReduce = (cmp) => () => a => b => {
     const sign = cmp(a)(b);
     return [sign === 1 ? b : a, sign, null];
 };
 const mergeTail = () => identity;
-export const find = cmp => value => array => {
+export const find = (cmp) => (value) => (array) => {
     let b = 0;
     let e = array.length - 1;
     while (true) {

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

@@ -1,3 +1,31 @@
+/**
+ * A sorted set, implemented as a sorted array.
+ *
+ * @module
+ *
+ * @note
+ *
+ * All input arrays must be pre-sorted according to the provided comparison function (`Cmp<T>`).
+ * The correctness of these functions depend on this requirement.
+ *
+ * @example
+ *
+ * ```js
+ * import { union, intersect, has } from './module.f.ts'
+ *
+ * const cmp = (a: number) => (b: number) => a < b ? -1 : a > b ? 1 : 0
+ *
+ * const setA = [1, 3, 5]
+ * const setB = [3, 4, 5]
+ *
+ * const unionSet = union(cmp)(setA)(setB) // [1, 3, 4, 5]
+ *
+ * const intersectionSet = intersect(cmp)(setA)(setB) // [3, 5]
+ *
+ * has(cmp)(3)(setA) // true
+ * has(cmp)(2)(setA) // false
+ * ```
+ */
 import type { Sign } from '../function/compare/module.f.ts';
 export type SortedSet<T> = readonly T[];
 type Cmp<T> = (a: T) => (b: T) => Sign;

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

@@ -1,4 +1,5 @@
 declare const _default: {
+    example: () => void;
     union: (() => void)[];
     intersect: (() => void)[];
     has: (() => void)[];

package/types/sorted_set/test.f.js

@@ -7,6 +7,25 @@ import { flip } from "../function/module.f.js";
 const stringify = a => json.stringify(sort)(a);
 const reverseCmp = flip(unsafeCmp);
 export default {
+    example: () => {
+        const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
+        const setA = [1, 3, 5];
+        const setB = [3, 4, 5];
+        const unionSet = union(cmp)(setA)(setB); // [1, 3, 4, 5]
+        if (stringify(unionSet) !== '[1,3,4,5]') {
+            throw 0;
+        }
+        const intersectionSet = intersect(cmp)(setA)(setB); // [3, 5]
+        if (stringify(intersectionSet) !== '[3,5]') {
+            throw 1;
+        }
+        if (!has(cmp)(3)(setA)) {
+            throw 2;
+        }
+        if (has(cmp)(2)(setA)) {
+            throw 3;
+        }
+    },
     union: [
         () => {
             const result = stringify(toArray(union(unsafeCmp)([2, 3, 4])([1, 3, 5])));

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

@@ -1,3 +1,20 @@
+/**
+ * Utility functions for working with strings and lists of strings.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { join, concat, repeat, cmp } from './module.f.ts'
+ *
+ * const words = ['hello', 'world']
+ * join(' ')(words) // 'hello world'
+ * concat(words) // 'helloworld'
+ * repeat('abc')(3) // 'abcabcabc'
+ * cmp('apple')('banana') // -1
+ * ```
+ */
 import { type List } from '../list/module.f.ts';
 import { type Sign } from '../function/compare/module.f.ts';
 export declare const join: (_: string) => (input: List<string>) => string;

package/types/string/module.f.js

@@ -1,3 +1,20 @@
+/**
+ * Utility functions for working with strings and lists of strings.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { join, concat, repeat, cmp } from './module.f.ts'
+ *
+ * const words = ['hello', 'world']
+ * join(' ')(words) // 'hello world'
+ * concat(words) // 'helloworld'
+ * repeat('abc')(3) // 'abcabcabc'
+ * cmp('apple')('banana') // -1
+ * ```
+ */
 import { reduce as listReduce, repeat as listRepeat } from "../list/module.f.js";
 import { compose } from "../function/module.f.js";
 import { unsafeCmp } from "../function/compare/module.f.js";

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

@@ -1,4 +1,5 @@
 declare const _default: {
+    example: () => void;
     join: {
         0: () => void;
         1: () => void;

package/types/string/test.f.js

@@ -1,6 +1,21 @@
 import { join, concat, repeat, cmp } from "./module.f.js";
 import { repeat as repeatList } from "../list/module.f.js";
 export default {
+    example: () => {
+        const words = ['hello', 'world'];
+        if (join(' ')(words) !== 'hello world') {
+            throw 0;
+        }
+        if (concat(words) !== 'helloworld') {
+            throw 1;
+        }
+        if (repeat('abc')(3) !== 'abcabcabc') {
+            throw 2;
+        }
+        if (cmp('apple')('banana') !== -1) {
+            throw 3;
+        }
+    },
     join: {
         0: () => {
             const result = join('/')([]);

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

@@ -1,3 +1,24 @@
+/**
+ * A set of strings implemented as a B-Tree.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { set, contains, remove, fromValues, values, empty } from './module.d.ts';
+ *
+ * let mySet = fromValues(['apple', 'banana', 'cherry']);
+ * if (!contains('banana')(mySet)) { throw '1' }
+ * if (contains('date')(mySet)) { throw '2' }
+ *
+ * mySet = set('date')(mySet);
+ * if (!contains('date')(mySet)) { throw '3' }
+ *
+ * mySet = remove('banana')(mySet);
+ * if (contains('banana')(mySet)) { throw '4' }
+ * ```
+ */
 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>;

package/types/string_set/module.f.js

@@ -1,3 +1,24 @@
+/**
+ * A set of strings implemented as a B-Tree.
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```js
+ * import { set, contains, remove, fromValues, values, empty } from './module.d.ts';
+ *
+ * let mySet = fromValues(['apple', 'banana', 'cherry']);
+ * if (!contains('banana')(mySet)) { throw '1' }
+ * if (contains('date')(mySet)) { throw '2' }
+ *
+ * mySet = set('date')(mySet);
+ * if (!contains('date')(mySet)) { throw '3' }
+ *
+ * mySet = remove('banana')(mySet);
+ * if (contains('banana')(mySet)) { throw '4' }
+ * ```
+ */
 import * as btree from "../btree/module.f.js";
 import { find, isFound } from "../btree/find/module.f.js";
 import { remove as btreeRemove } from "../btree/remove/module.f.js";

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

@@ -1,4 +1,5 @@
 declare const _default: {
+    example: () => void;
     contains: () => void;
     remove: () => void;
 };

package/types/string_set/test.f.js

@@ -1,5 +1,22 @@
-import { contains, remove, set } from "./module.f.js";
+import { contains, fromValues, remove, set } from "./module.f.js";
 export default {
+    example: () => {
+        let mySet = fromValues(['apple', 'banana', 'cherry']);
+        if (!contains('banana')(mySet)) {
+            throw '1';
+        }
+        if (contains('date')(mySet)) {
+            throw '2';
+        }
+        mySet = set('date')(mySet);
+        if (!contains('date')(mySet)) {
+            throw '3';
+        }
+        mySet = remove('banana')(mySet);
+        if (contains('banana')(mySet)) {
+            throw '4';
+        }
+    },
     contains: () => {
         const r = set('hello')(null);
         if (!contains('hello')(r)) {