functionalscript 0.1.608 → 0.2.0

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

@@ -1,9 +1,9 @@
 // @ts-self-types="./module.f.d.mts"
 import * as _ from '../types/module.f.mjs'
-import btreeFind, * as BtreeFind from '../find/module.f.mjs'
+import * as btreeFind from '../find/module.f.mjs'
 const { find } = btreeFind
 import * as Cmp from '../../function/compare/module.f.mjs'
-import list from '../../list/module.f.mjs'
+import * as list from '../../list/module.f.mjs'
 const { fold } = list
 
 /**
@@ -14,7 +14,7 @@ const { fold } = list
 /** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Branch1To3<T>} */
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(i: BtreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
+/** @type {<T>(i: btreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
 const reduceOp = ([i, x]) => a => {
     switch (i) {
         case 0: {
@@ -89,9 +89,4 @@ const nodeSet = c => g => node => {
 }
 
 /** @type {<T>(c: Cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
-const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree)
-
-export default {
-    /** @readonly */
-    set,
-}
+export const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree)

package/types/btree/set/test.f.mjs

@@ -1,9 +1,9 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 import * as BTree from '../types/module.f.mjs'
-import s from '../../string/module.f.mjs'
+import * as s from '../../string/module.f.mjs'
 const { cmp } = s
-import json from '../../../json/module.f.mjs'
-import o from '../../object/module.f.mjs'
+import * as json from '../../../json/module.f.mjs'
+import * as o from '../../object/module.f.mjs'
 const { sort } = o
 
 /** @type {(node: BTree.Node<string>) => (value: string) => BTree.Node<string>} */

package/types/btree/test.f.mjs

@@ -1,18 +1,18 @@
 import * as BTree from './types/module.f.mjs'
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { values } = _
-import json, * as jsonT from '../../json/module.f.mjs'
-import o from '../object/module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../object/module.f.mjs'
 const { sort } = o
-import str from '../string/module.f.mjs'
+import * as str from '../string/module.f.mjs'
 const { cmp } = str
-import list, * as List from '../list/module.f.mjs'
-import s from './set/module.f.mjs'
-import f from './find/module.f.mjs'
+import * as list from '../list/module.f.mjs'
+import * as s from './set/module.f.mjs'
+import * as f from './find/module.f.mjs'
 
 const jsonStr = json.stringify(sort)
 
-/** @type {(sequence: List.List<jsonT.Unknown>) => string} */
+/** @type {(sequence: list.List<json.Unknown>) => string} */
 const stringify = sequence => jsonStr(list.toArray(sequence))
 
 /** @type {(node: BTree.Node<string>) => (value: string) => BTree.Node<string>} */
@@ -67,7 +67,7 @@ const test = () => {
     _map = set(_map)('f')
     //
     {
-        /** @type {List.Result<string>} */
+        /** @type {list.Result<string>} */
         let _item = list.next(values(_map))
         while (_item !== null) {
             _item = list.next(_item.tail)

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

@@ -1,5 +1,3 @@
-declare const _default: {};
-export default _default;
 export type Array1<T> = readonly [T];
 export type Array2<T> = readonly [T, T];
 export type Array3<T> = readonly [T, T, T];

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

@@ -62,5 +62,3 @@
  * @template T
  * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
  */
-
-export default {}

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

@@ -1,38 +1,25 @@
-declare namespace _default {
-    export { empty };
-    export { universe };
-    export { has };
-    export { set };
-    export { unset };
-    export { one };
-    export { union };
-    export { setRange };
-    export { range };
-    export { complement };
-    export { toRangeMap };
-}
-export default _default;
-export type ByteSet = bigint;
-export type Byte = number;
-declare const empty: 0n;
-declare const universe: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
 /** @typedef {bigint} ByteSet */
 /** @typedef {number} Byte */
 /** @type {(n: Byte) => (s: ByteSet) => boolean} */
-declare const has: (n: Byte) => (s: ByteSet) => boolean;
-declare const set: import("../function/module.f.mjs").Func<number, (b: ByteSet) => ByteSet>;
-/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
-declare const unset: (n: Byte) => (s: ByteSet) => ByteSet;
+export const has: (n: Byte) => (s: ByteSet) => boolean;
+export const empty: 0n;
+export const universe: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
 /** @type {(n: Byte) => ByteSet} */
-declare const one: (n: Byte) => ByteSet;
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-declare const union: (a: ByteSet) => (b: ByteSet) => ByteSet;
-declare const setRange: import("../function/module.f.mjs").Func<readonly [number, number], (b: ByteSet) => ByteSet>;
+export const one: (n: Byte) => ByteSet;
 /** @type {(r: readonly[Byte, Byte]) => ByteSet} */
-declare const range: (r: readonly [Byte, Byte]) => ByteSet;
+export const range: (r: readonly [Byte, Byte]) => ByteSet;
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+export const union: (a: ByteSet) => (b: ByteSet) => ByteSet;
 /** @type {(n: ByteSet) => ByteSet} */
-declare const complement: (n: ByteSet) => ByteSet;
+export const complement: (n: ByteSet) => ByteSet;
+export const set: f.Func<number, (b: ByteSet) => ByteSet>;
+export const setRange: f.Func<readonly [number, number], (b: ByteSet) => ByteSet>;
+/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
+export const unset: (n: Byte) => (s: ByteSet) => ByteSet;
 /** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-declare const toRangeMap: (n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>;
+export const toRangeMap: (n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>;
+export type ByteSet = bigint;
+export type Byte = number;
+import * as f from '../function/module.f.mjs';
 import * as RangeMap from '../range_map/module.f.mjs';
 import * as SortedSet from '../sorted_set/module.f.mjs';

package/types/byte_set/module.f.mjs

@@ -1,52 +1,52 @@
 // @ts-self-types="./module.f.d.mts"
-import f from '../function/module.f.mjs'
+import * as f from '../function/module.f.mjs'
 const { compose } = f
 import * as RangeMap from '../range_map/module.f.mjs'
 import * as SortedSet from '../sorted_set/module.f.mjs'
-import list from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { reverse, countdown, flat, map } = list
 
 /** @typedef {bigint} ByteSet */
 /** @typedef {number} Byte */
 
 /** @type {(n: Byte) => (s: ByteSet) => boolean} */
-const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
+export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
 
 // create a set
 
-const empty = 0n
+export const empty = 0n
 
-//                 0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-const universe = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFFn
+//                        0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
+export const universe = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFFn
 
 /** @type {(n: Byte) => ByteSet} */
-const one = n => 1n << BigInt(n)
+export const one = n => 1n << BigInt(n)
 
 /** @type {(r: readonly[Byte, Byte]) => ByteSet} */
-const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b)
+export const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b)
 
 // set operations
 
 /** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-const union = a => b => a | b
+export const union = a => b => a | b
 
 /** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
 const intersect = a => b => a & b
 
 /** @type {(n: ByteSet) => ByteSet} */
-const complement = n => universe ^ n
+export const complement = n => universe ^ n
 
 /** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
 const difference = compose(intersect)(compose(complement))
 
 // additional operations
 
-const set = compose(one)(union)
+export const set = compose(one)(union)
 
-const setRange = compose(range)(union)
+export const setRange = compose(range)(union)
 
 /** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
-const unset = n => s => difference(s)(one(n))
+export const unset = n => s => difference(s)(one(n))
 
 const counter = reverse(countdown(256))
 
@@ -58,29 +58,4 @@ const toRangeMapOp = n => s => i => {
 }
 
 /** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter))
-
-export default {
-    /** @readonly */
-    empty,
-    /** @readonly */
-    universe,
-    /** @readonly */
-    has,
-    /** @readonly */
-    set,
-    /** @readonly */
-    unset,
-    /** @readonly */
-    one,
-    /** @readonly */
-    union,
-    /** @readonly */
-    setRange,
-    /** @readonly */
-    range,
-    /** @readonly */
-    complement,
-    /** @readonly */
-    toRangeMap,
-}
+export const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter))

package/types/byte_set/test.f.mjs

@@ -1,11 +1,11 @@
-import _ from './module.f.mjs'
-import list from '../list/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { every, countdown, map, toArray } = list
-import json, * as Json from '../../json/module.f.mjs'
-import o from '../object/module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../object/module.f.mjs'
 const { sort } = o
 
-/** @type {(a: readonly Json.Unknown[]) => string} */
+/** @type {(a: readonly json.Unknown[]) => string} */
 const stringify = json.stringify(sort)
 
 export default {

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

@@ -1,16 +1,3 @@
-declare namespace _default {
-    export { unsafeCmp };
-    export { index3 };
-    export { index5 };
-}
-export default _default;
-export type Index3 = Array.Index3;
-export type Index5 = Array.Index5;
-export type Array2<T> = Array.Array2<T>;
-export type Sign = -1 | 0 | 1;
-export type Compare<T> = (_: T) => Sign;
-/** @type {<T>(a: T) => (b: T) => Sign} */
-declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
 /** @typedef {Array.Index3} Index3 */
 /** @typedef {Array.Index5} Index5 */
 /**
@@ -23,7 +10,14 @@ declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
  * @typedef {(_: T) => Sign} Compare
  */
 /** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
-declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
+export const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
 /** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
-declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
+export const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
+/** @type {<T>(a: T) => (b: T) => Sign} */
+export const unsafeCmp: <T>(a: T) => (b: T) => Sign;
+export type Index3 = Array.Index3;
+export type Index5 = Array.Index5;
+export type Array2<T> = Array.Array2<T>;
+export type Sign = -1 | 0 | 1;
+export type Compare<T> = (_: T) => Sign;
 import * as Array from '../../array/module.f.mjs';

package/types/function/compare/module.f.mjs

@@ -17,22 +17,13 @@ import * as Array from '../../array/module.f.mjs'
  */
 
 /** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
-const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
+export const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
 
 /** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
-const index5 = cmp => ([v0, v1]) => {
+export const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0)
     return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3)
 }
 
 /** @type {<T>(a: T) => (b: T) => Sign} */
-const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0
-
-export default {
-    /** @readonly */
-    unsafeCmp,
-    /** @readonly */
-    index3,
-    /** @readonly */
-    index5,
-}
+export const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0

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

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { unsafeCmp } = _
 
 export default () => {

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

@@ -1,27 +1,3 @@
-declare namespace _default {
-    export { identity };
-    export { compose };
-    export { flip };
-    export { fn };
-}
-export default _default;
-/**
- * A generic function type.
- */
-export type Func<I, O> = (_: I) => O;
-/**
- * A functional utility type that enables seamless chaining of transformations.
- */
-export type Fn<I, O> = {
-    readonly result: Func<I, O>;
-    readonly then: <T>(g: Func<O, T>) => Fn<I, T>;
-};
-/**
- * A generic identity function.
- *
- * @type {<T>(value: T) => T}
- */
-declare const identity: <T>(value: T) => T;
 /**
  * A generic function type.
  *
@@ -34,13 +10,19 @@ declare const identity: <T>(value: T) => T;
  *
  * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
  */
-declare const compose: <I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>;
+export const compose: <I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>;
+/**
+ * A generic identity function.
+ *
+ * @type {<T>(value: T) => T}
+ */
+export const identity: <T>(value: T) => T;
 /**
  * Flips the arguments of a curried function.
  *
  * @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C}
  */
-declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
+export const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
 /**
  * A functional utility type that enables seamless chaining of transformations.
  *
@@ -55,4 +37,15 @@ declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C
  *
  * @type {<I, O>(f: (i: I) => O) => Fn<I, O>}
  */
-declare const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
+export const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
+/**
+ * A generic function type.
+ */
+export type Func<I, O> = (_: I) => O;
+/**
+ * A functional utility type that enables seamless chaining of transformations.
+ */
+export type Fn<I, O> = {
+    readonly result: Func<I, O>;
+    readonly then: <T>(g: Func<O, T>) => Fn<I, T>;
+};

package/types/function/module.f.mjs

@@ -13,21 +13,21 @@
  *
  * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
  */
-const compose = g => f => x => f(g(x))
+export const compose = g => f => x => f(g(x))
 
 /**
  * A generic identity function.
  *
  * @type {<T>(value: T) => T}
  */
-const identity = value => value
+export const identity = value => value
 
 /**
  * Flips the arguments of a curried function.
  *
  * @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C}
  */
-const flip = f => b => a => f(a)(b)
+export const flip = f => b => a => f(a)(b)
 
 /**
  * A functional utility type that enables seamless chaining of transformations.
@@ -44,18 +44,7 @@ const flip = f => b => a => f(a)(b)
  *
  * @type {<I, O>(f: (i: I) => O) => Fn<I, O>}
  */
-const fn = result => ({
+export const fn = result => ({
     result,
     then: g => fn(compose(result)(g))
 })
-
-export default {
-    /** @readonly */
-    identity,
-    /** @readonly */
-    compose,
-    /** @readonly */
-    flip,
-    /** @readonly */
-    fn,
-}

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

@@ -1,25 +1,3 @@
-declare namespace _default {
-    export { join };
-    export { addition };
-    export { increment };
-    export { strictEqual };
-    export { logicalNot };
-    export { min };
-    export { max };
-    export { stateScanToScan };
-    export { foldToScan };
-    export { reduceToScan };
-    export { counter };
-    export { concat };
-}
-export default _default;
-export type Binary<A, B, R> = (a: A) => (b: B) => R;
-export type Fold<I, O> = Binary<I, O, O>;
-export type Unary<T, R> = (value: T) => R;
-export type Equal<T> = Binary<T, T, boolean>;
-export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
-export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
-export type Reduce<T> = Fold<T, T>;
 /**
  * @template A
  * @template B
@@ -31,27 +9,22 @@ export type Reduce<T> = Fold<T, T>;
  * @typedef {Binary<I, O, O>} Fold
  */
 /** @type {(separator: string) => Reduce<string>} */
-declare const join: (separator: string) => Reduce<string>;
-/** @type {Reduce<number>} */
-declare const addition: Reduce<number>;
-declare const increment: (b: number) => number;
-/**
- * @template T
- * @typedef {Binary<T, T, boolean>} Equal
- */
-/** @type {<T>(a: T) => (b: T) => boolean} */
-declare const strictEqual: <T>(a: T) => (b: T) => boolean;
+export const join: (separator: string) => Reduce<string>;
+/** @type {Reduce<string>} */
+export const concat: Reduce<string>;
 /**
  * @template T
  * @template R
  * @typedef {(value: T) => R} Unary
  */
 /** @type {Unary<boolean, boolean>} */
-declare const logicalNot: Unary<boolean, boolean>;
-/** @type {Reduce<number>} */
-declare const min: Reduce<number>;
-/** @type {Reduce<number>} */
-declare const max: Reduce<number>;
+export const logicalNot: Unary<boolean, boolean>;
+/**
+ * @template T
+ * @typedef {Binary<T, T, boolean>} Equal
+ */
+/** @type {<T>(a: T) => (b: T) => boolean} */
+export const strictEqual: <T>(a: T) => (b: T) => boolean;
 /**
  * @template I,O
  * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
@@ -61,15 +34,27 @@ declare const max: Reduce<number>;
  * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
  */
 /** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
+export const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
 /** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
+export const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
 /**
  * @template T
  * @typedef {Fold<T, T>} Reduce
  */
 /** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
-declare function counter(): (b: number) => number;
-/** @type {Reduce<string>} */
-declare const concat: Reduce<string>;
+export const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
+/** @type {Reduce<number>} */
+export const addition: Reduce<number>;
+/** @type {Reduce<number>} */
+export const min: Reduce<number>;
+/** @type {Reduce<number>} */
+export const max: Reduce<number>;
+export const increment: (b: number) => number;
+export function counter(): (b: number) => number;
+export type Binary<A, B, R> = (a: A) => (b: B) => R;
+export type Fold<I, O> = Binary<I, O, O>;
+export type Unary<T, R> = (value: T) => R;
+export type Equal<T> = Binary<T, T, boolean>;
+export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
+export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
+export type Reduce<T> = Fold<T, T>;

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

@@ -12,10 +12,10 @@
  */
 
 /** @type {(separator: string) => Reduce<string>} */
-const join = separator => value => prior => `${prior}${separator}${value}`
+export const join = separator => value => prior => `${prior}${separator}${value}`
 
 /** @type {Reduce<string>} */
-const concat = i => acc => `${acc}${i}`
+export const concat = i => acc => `${acc}${i}`
 
 /**
  * @template T
@@ -24,7 +24,7 @@ const concat = i => acc => `${acc}${i}`
  */
 
 /** @type {Unary<boolean, boolean>} */
-const logicalNot = v => !v
+export const logicalNot = v => !v
 
 /**
  * @template T
@@ -32,7 +32,7 @@ const logicalNot = v => !v
  */
 
 /** @type {<T>(a: T) => (b: T) => boolean} */
-const strictEqual = a => b => a === b
+export const strictEqual = a => b => a === b
 
 /**
  * @template I,O
@@ -45,13 +45,13 @@ const strictEqual = a => b => a === b
  */
 
 /** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-const stateScanToScan = op => prior => i => {
+export const stateScanToScan = op => prior => i => {
     const [o, s] = op(prior)(i)
     return [o, stateScanToScan(op)(s)]
 }
 
 /** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-const foldToScan = fold => prior => i => {
+export const foldToScan = fold => prior => i => {
     const result = fold(i)(prior)
     return [result, foldToScan(fold)(result)]
 }
@@ -62,44 +62,17 @@ const foldToScan = fold => prior => i => {
  */
 
 /** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-const reduceToScan = op => init => [init, foldToScan(op)(init)]
+export const reduceToScan = op => init => [init, foldToScan(op)(init)]
 
 /** @type {Reduce<number>} */
-const addition = a => b => a + b
+export const addition = a => b => a + b
 
 /** @type {Reduce<number>} */
-const min = a => b => a < b ? a : b
+export const min = a => b => a < b ? a : b
 
 /** @type {Reduce<number>} */
-const max = a => b => a > b ? a : b
-
-const increment = addition(1)
-
-const counter = () => increment
-
-export default {
-    /** @readonly */
-    join,
-    /** @readonly */
-    addition,
-    /** @readonly */
-    increment,
-    /** @readonly */
-    strictEqual,
-    /** @readonly */
-    logicalNot,
-    /** @readonly */
-    min,
-    /** @readonly */
-    max,
-    /** @readonly */
-    stateScanToScan,
-    /** @readonly */
-    foldToScan,
-    /** @readonly */
-    reduceToScan,
-    /** @readonly */
-    counter,
-    /** @readonly */
-    concat,
-}
+export const max = a => b => a > b ? a : b
+
+export const increment = addition(1)
+
+export const counter = () => increment

package/types/function/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 const { fn } = _