functionalscript 0.1.609 → 0.2.0

package/types/btree/module.f.mjs

@@ -1,12 +1,12 @@
 // @ts-self-types="./module.f.d.mts"
 
-import list, * as List from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { flat } = list
-import n from '../nullable/module.f.mjs'
+import * as n from '../nullable/module.f.mjs'
 const { map } = n
 import * as _ from './types/module.f.mjs'
 
-/** @type {<T>(node: _.Node<T>) => List.Thunk<T>} */
+/** @type {<T>(node: _.Node<T>) => list.Thunk<T>} */
 const nodeValues = node => () => {
     switch (node.length) {
         case 1: case 2: { return node }
@@ -29,12 +29,7 @@ const nodeValues = node => () => {
     }
 }
 
-/** @type {<T>(tree: _.Tree<T>) => List.List<T>} */
-const values = map(nodeValues)
+export const empty = null
 
-export default {
-    /** @readonly */
-    empty: null,
-    /** @readonly */
-    values,
-}
+/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+export const values = map(nodeValues)

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

@@ -1,19 +1,14 @@
-declare namespace _default {
-    export { nodeRemove };
-    export { remove };
-}
-export default _default;
+/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+export const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
+/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+export const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
 export type Leaf01<T> = null | _.Leaf1<T>;
 export type RemovePath<T> = {
     readonly first: Leaf01<T>;
-    readonly tail: Find.Path<T>;
+    readonly tail: find.Path<T>;
 };
 export type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>;
 export type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>;
-/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-declare const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
-/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-declare const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
-import * as _ from '../types/module.f.mjs';
-import * as Find from '../find/module.f.mjs';
 import * as Cmp from '../../function/compare/module.f.mjs';
+import * as _ from '../types/module.f.mjs';
+import * as find from '../find/module.f.mjs';

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

@@ -1,11 +1,11 @@
 // @ts-self-types="./module.f.d.mts"
 import * as _ from '../types/module.f.mjs'
 import * as Cmp from '../../function/compare/module.f.mjs'
-import find, * as Find from '../find/module.f.mjs'
-import list from '../../list/module.f.mjs'
+import * as find from '../find/module.f.mjs'
+import * as list from '../../list/module.f.mjs'
 const { fold, concat, next } = list
 import * as Array from '../../array/module.f.mjs'
-import n from '../../nullable/module.f.mjs'
+import * as n from '../../nullable/module.f.mjs'
 const { map } = n
 
 /**
@@ -17,11 +17,11 @@ const { map } = n
  * @template T
  * @typedef {{
  *  readonly first: Leaf01<T>,
- *  readonly tail: Find.Path<T>
+ *  readonly tail: find.Path<T>
  * }} RemovePath
  */
 
-/** @type {<T>(tail: Find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
+/** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
 const path = tail => n => {
     switch (n.length) {
         case 1: { return [n[0], { first: null, tail }] }
@@ -95,7 +95,7 @@ const initValue1 = a => n => {
  * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
  */
 
-/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: Find.PathItem<T>) => (a: A) => Branch<T>} */
+/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: find.PathItem<T>) => (a: A) => Branch<T>} */
 const reduceX = ms => ([i, n]) => a => {
     const [m0, m2] = ms
     /** @typedef {typeof ms extends Array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
@@ -118,14 +118,14 @@ const reduce = fold(reduceX([reduceValue0, reduceValue2]))
 const initReduce = reduceX([initValue0, initValue1])
 
 /** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-const nodeRemove = c => node => {
+export const nodeRemove = c => node => {
     /** @typedef {typeof c extends Cmp.Compare<infer T> ? T : never} T */
     /** @type  {() => null | RemovePath<T>} */
     const f = () => {
         const { first, tail } = find.find(c)(node)
-        /** @type {(n: _.Node<T>) => (f: (v: T) => Find.PathItem<T>) => RemovePath<T>} */
+        /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
         const branch = n => f => {
-            const [v, p] = path(/** @type {Find.Path<T>} */(null))(n)
+            const [v, p] = path(/** @type {find.Path<T>} */(null))(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
@@ -158,11 +158,4 @@ const nodeRemove = c => node => {
 }
 
 /** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-const remove =  c => map(nodeRemove(c))
-
-export default {
-    /** @readonly */
-    nodeRemove,
-    /** @readonly */
-    remove,
-}
+export const remove =  c => map(nodeRemove(c))

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

@@ -1,10 +1,10 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 import * as BTree from '../types/module.f.mjs'
-import s from '../set/module.f.mjs'
-import str from '../../string/module.f.mjs'
+import * as s from '../set/module.f.mjs'
+import * as str from '../../string/module.f.mjs'
 const { cmp } = str
-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/set/module.f.d.mts

@@ -1,9 +1,5 @@
-declare namespace _default {
-    export { set };
-}
-export default _default;
-export type Branch1To3<T> = _.Branch1<T> | _.Branch3<T>;
 /** @type {<T>(c: Cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
-declare const set: <T>(c: Cmp.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.Node<T>;
-import * as _ from '../types/module.f.mjs';
+export const set: <T>(c: Cmp.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.Node<T>;
+export type Branch1To3<T> = _.Branch1<T> | _.Branch3<T>;
 import * as Cmp from '../../function/compare/module.f.mjs';
+import * as _ from '../types/module.f.mjs';

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,
-}