functionalscript 0.3.7 → 0.3.9

package/types/bit_vec/test.f.js

@@ -1,4 +1,73 @@
-import { empty, vec, length, concatLsb, uintLsb, uintMsb, removeLsb, concatMsb, removeMsb, uint, popUintLsb, popUintMsb } from "./module.f.js";
+import { empty, vec, length, uint, lsb, msb } from "./module.f.js";
+const frontTest = (e) => (r0) => (r1) => () => {
+    const vector = vec(8n)(0xf5n); // 0x1F5n
+    if (vector !== 0x1f5n) {
+        throw vector;
+    }
+    const result = e.front(4n)(vector);
+    if (result !== r0) {
+        throw result;
+    }
+    const result2 = e.front(16n)(vector);
+    if (result2 !== r1) {
+        throw result2;
+    }
+};
+const popFront = (e) => ([r00, r01]) => ([r10, r11]) => () => {
+    const vector = vec(8n)(0xf5n); // 0x1F5n
+    const [result, rest] = e.popFront(4n)(vector);
+    if (result !== r00) {
+        throw result;
+    }
+    if (rest !== r01) {
+        throw rest;
+    }
+    const [result2, rest2] = e.popFront(16n)(vector);
+    if (result2 !== r10) {
+        throw result2;
+    }
+    if (rest2 !== r11) {
+        throw rest2;
+    }
+};
+const removeFront = (e) => (r0) => (r1) => () => {
+    const v = vec(16n)(0x3456n); // 0x13456n
+    if (v !== 0x13456n) {
+        throw v;
+    }
+    const r = e.removeFront(4n)(v);
+    if (r !== r0) {
+        throw r;
+    }
+    const r2 = e.removeFront(24n)(v);
+    if (r2 !== r1) {
+        throw r2;
+    }
+};
+const concat = (e) => (r) => () => {
+    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 = e.concat(a)(b); // 0x18945n
+    if (ab !== r) {
+        throw ab;
+    }
+};
+const assertEq = (a, b) => {
+    if (a !== b) {
+        throw [a, b];
+    }
+};
+const assertEq2 = ([a0, a1], [b0, b1]) => {
+    assertEq(a0, b0);
+    assertEq(a1, b1);
+};
 export default {
     examples: {
         vec: () => {
@@ -22,130 +91,54 @@ export default {
                 throw result;
             }
         },
-        uintLsb: () => {
+        front: () => {
             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;
-            }
+            assertEq(lsb.front(4n)(vector), 5n);
+            assertEq(lsb.front(16n)(vector), 0xf5n);
+            assertEq(msb.front(4n)(vector), 0xfn);
+            assertEq(msb.front(16n)(vector), 0xf500n);
         },
-        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;
-            }
+        removeFront: () => {
+            const v = vec(16n)(0x3456n); // 0x13456n
+            assertEq(lsb.removeFront(4n)(v), 0x1345n);
+            assertEq(lsb.removeFront(24n)(v), 0x1n);
+            assertEq(msb.removeFront(4n)(v), 0x1456n);
+            assertEq(msb.removeFront(24n)(v), 0x1n);
         },
-        popUintMsb: () => {
+        popFront: () => {
             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;
-            }
+            assertEq2(lsb.popFront(4n)(vector), [5n, 0x1fn]);
+            assertEq2(lsb.popFront(16n)(vector), [0xf5n, 1n]);
+            assertEq2(msb.popFront(4n)(vector), [0xfn, 0x15n]);
+            assertEq2(msb.popFront(16n)(vector), [0xf500n, 1n]);
         },
-        concatMsb: () => {
+        concat: () => {
             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;
-            }
+            assertEq(lsb.concat(a)(b), 0x18945n);
+            assertEq(msb.concat(a)(b), 0x14589n);
         }
     },
+    front: {
+        lsbf: frontTest(lsb)(5n)(0xf5n),
+        msbf: frontTest(msb)(0xfn)(0xf500n),
+    },
+    popFront: {
+        lsbm: popFront(lsb)([5n, 0x1fn])([0xf5n, 1n]),
+        msbm: popFront(msb)([0xfn, 0x15n])([0xf500n, 1n]),
+    },
+    removeFront: {
+        lsbm: removeFront(lsb)(0x1345n)(0x1n),
+        msbm: removeFront(msb)(0x1456n)(0x1n),
+    },
+    concat: {
+        lsbm: concat(lsb)(0x18945n),
+        msbm: concat(msb)(0x14589n),
+    },
     uintLsb: () => {
         const vector = 117n;
-        const extract3Bits = uintLsb(3n);
+        const extract3Bits = lsb.front(3n);
         const result = extract3Bits(vector); // result is 0b101n (5n)
         if (result !== 5n) {
             throw result;
@@ -153,7 +146,7 @@ export default {
     },
     uintSmall: () => {
         const vector = 3n;
-        const extract3Bits = uintLsb(3n)(vector);
+        const extract3Bits = lsb.front(3n)(vector);
         if (extract3Bits !== 1n) {
             throw extract3Bits;
         }
@@ -179,7 +172,7 @@ export default {
         if (length(v) !== 8n) {
             throw 'len';
         }
-        const u = uintLsb(8n)(v);
+        const u = lsb.front(8n)(v);
         if (u !== 0xfen) {
             throw v;
         }
@@ -188,7 +181,7 @@ export default {
         const vec8 = vec(8n);
         const a = vec8(0x345n);
         const b = vec8(0x789n);
-        const ab = concatLsb(a)(b);
+        const ab = lsb.concat(a)(b);
         if (ab !== 0x18945n) {
             throw ab;
         }
@@ -202,7 +195,7 @@ export default {
         if (v !== 0x32345n) {
             throw v.toString(16);
         }
-        const r = removeLsb(9n)(v);
+        const r = lsb.removeFront(9n)(v);
         if (r !== 0x191n) {
             throw r.toString(16);
         }

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

@@ -1,11 +1,8 @@
 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 { sort } from "../../object/module.f.js";
+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);
@@ -13,8 +10,9 @@ 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++)
+    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"]]]') {

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

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

package/types/btree/module.f.js

@@ -1,8 +1,5 @@
-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";
+import { flat } from "../list/module.f.js";
+import { map } from "../nullable/module.f.js";
 const nodeValues = node => () => {
     switch (node.length) {
         case 1:

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

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/set/test.f.js

@@ -1,11 +1,8 @@
 import * as _ from "./module.f.js";
-import * as BTree from "../types/module.f.js";
-import * as s from "../../string/module.f.js";
-const { cmp } = s;
+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;
-const set = node => value => _.set(cmp(value))(() => value)(node);
+import { sort } from "../../object/module.f.js";
+const set = (node) => (value) => _.set(cmp(value))(() => value)(node);
 const jsonStr = json.stringify(sort);
 const test = [
     () => {

package/types/btree/test.f.js

@@ -1,16 +1,12 @@
-import * as BTree from "./types/module.f.js";
-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'];
@@ -19,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;
     }
@@ -28,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;
     }
@@ -60,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,5 +1,4 @@
-type Array1<T> = readonly [T];
-type Array2<T> = readonly [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>];
@@ -8,4 +7,3 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
-export {};

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

@@ -1,5 +1,5 @@
-import * as RangeMap from '../range_map/module.f.ts';
-import * 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,8 +1,5 @@
 import { compose } from "../function/module.f.js";
-import * as RangeMap from "../range_map/module.f.js";
-import * as SortedSet from "../sorted_set/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 * 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/function/compare/module.f.js

@@ -1,4 +1,3 @@
-import * as Array from "../../array/module.f.js";
 export const index3 = cmp => value => (cmp(value) + 1);
 export const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0);

package/types/function/compare/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { unsafeCmp } = _;
+import { unsafeCmp } from "./module.f.js";
 export default () => {
     const result = unsafeCmp(true)(false);
     if (result !== 1) {

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

@@ -24,5 +24,5 @@ type Fn<I, O> = {
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.
  */
-export declare const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
+export declare const fn: <I, O>(result: Func<I, O>) => Fn<I, O>;
 export {};

package/types/function/module.f.js

@@ -13,7 +13,7 @@ export const flip = f => b => a => f(a)(b);
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.
  */
-export const fn = result => ({
+export const fn = (result) => ({
     result,
     then: g => fn(compose(result)(g))
 });

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

@@ -1,4 +1,4 @@
-type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
 export type Fold<I, O> = Binary<I, O, O>;
 export declare const join: (separator: string) => Reduce<string>;
 export declare const concat: Reduce<string>;
@@ -11,10 +11,9 @@ export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
 export declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
 export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
 export type Reduce<T> = Fold<T, T>;
-export declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+export declare const reduceToScan: <T>(op: Reduce<T>) => Scan<T, T>;
 export declare const addition: Reduce<number>;
 export declare const min: Reduce<number>;
 export declare const max: Reduce<number>;
 export declare const increment: (b: number) => number;
 export declare const counter: () => (b: number) => number;
-export {};

package/types/function/operator/module.f.js

@@ -1,16 +1,16 @@
-export const join = separator => value => prior => `${prior}${separator}${value}`;
+export const join = (separator) => value => prior => `${prior}${separator}${value}`;
 export const concat = i => acc => `${acc}${i}`;
 export const logicalNot = v => !v;
-export const strictEqual = a => b => a === b;
-export const stateScanToScan = op => prior => i => {
+export const strictEqual = (a) => (b) => a === b;
+export const stateScanToScan = (op) => (prior) => i => {
     const [o, s] = op(prior)(i);
     return [o, stateScanToScan(op)(s)];
 };
-export const foldToScan = fold => prior => i => {
+export const foldToScan = (fold) => (prior) => i => {
     const result = fold(i)(prior);
     return [result, foldToScan(fold)(result)];
 };
-export const reduceToScan = op => init => [init, foldToScan(op)(init)];
+export const reduceToScan = (op) => init => [init, foldToScan(op)(init)];
 export const addition = a => b => a + b;
 export const min = a => b => a < b ? a : b;
 export const max = a => b => a > b ? a : b;

package/types/function/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { fn } = _;
+import { fn } from "./module.f.js";
 export default () => {
     const f = x => [x];
     const g = ([x]) => [x.length];

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

@@ -13,7 +13,7 @@ type Concat<T> = {
     readonly tail: List<T>;
 };
 export declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
-export declare const next: <T>(list: List<T>) => Result<T>;
+export declare const next: <T>(head: List<T>) => Result<T>;
 export declare const iterable: <T>(list: List<T>) => Iterable<T>;
 export declare const toArray: <T>(list: List<T>) => readonly T[];
 export declare const flat: <T>(list: List<List<T>>) => Thunk<T>;