functionalscript 0.1.608 → 0.2.0

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

@@ -1,117 +1,82 @@
-declare namespace _default {
-    export let empty: null;
-    export { concat };
-    export { next };
-    export { iterable };
-    export { toArray };
-    export { flat };
-    export { map };
-    export { flatMap };
-    export { filter };
-    export { filterMap };
-    export { takeWhile };
-    export { take };
-    export { dropWhile };
-    export { drop };
-    export { first };
-    export { last };
-    export { find };
-    export { some };
-    export { every };
-    export { isEmpty };
-    export { includes };
-    export { countdown };
-    export { repeat };
-    export { cycle };
-    export { scan };
-    export { stateScan };
-    export { foldScan };
-    export { fold };
-    export { reduce };
-    export { length };
-    export { entries };
-    export { reverse };
-    export { zip };
-    export { equal };
-}
-export default _default;
-export type List<T> = NotLazy<T> | Thunk<T>;
-export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
-export type Empty = null;
-export type Result<T> = Empty | NonEmpty<T>;
-export type Thunk<T> = () => List<T>;
-export type NonEmpty<T> = {
-    readonly first: T;
-    readonly tail: List<T>;
-};
-export type Concat<T> = {
-    readonly head: List<T>;
-    readonly tail: List<T>;
-};
-export type Entry<T> = readonly [number, T];
 /** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
-declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
+export const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
 /** @type {<T>(list: List<T>) => Result<T>} */
-declare const next: <T>(list: List<T>) => Result<T>;
+export const next: <T>(list: List<T>) => Result<T>;
 /** @type {<T>(list: List<T>) => Iterable<T>} */
-declare const iterable: <T>(list: List<T>) => Iterable<T>;
+export const iterable: <T>(list: List<T>) => Iterable<T>;
 /** @type {<T>(list: List<T>) => readonly T[]} */
-declare const toArray: <T>(list: List<T>) => readonly T[];
+export const toArray: <T>(list: List<T>) => readonly T[];
 /** @type {<T>(list: List<List<T>>) => Thunk<T>} */
-declare const flat: <T>(list: List<List<T>>) => Thunk<T>;
+export const flat: <T>(list: List<List<T>>) => Thunk<T>;
 /** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
-declare const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
+export const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
 /** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
-declare const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
+export const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-declare const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
 /** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
-declare const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
+export const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-declare const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-declare const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
+export const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-declare const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
+export const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-declare const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
+export const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
 /** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
-declare const first: <D>(def: D) => <T>(input: List<T>) => D | T;
+export const first: <D>(def: D) => <T>(input: List<T>) => D | T;
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
-declare const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
+export const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-declare const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
+export const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
 /** @type {(input: List<boolean>) => boolean} */
-declare const some: (input: List<boolean>) => boolean;
-declare const every: import("../function/module.f.mjs").Func<List<boolean>, boolean>;
+export const some: (input: List<boolean>) => boolean;
 /** @type {<T>(input: List<T>) => boolean} */
-declare const isEmpty: <T>(input: List<T>) => boolean;
+export const isEmpty: <T>(input: List<T>) => boolean;
+export const every: function_.Func<List<boolean>, boolean>;
 /** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-declare const includes: <T>(value: T) => (sequence: List<T>) => boolean;
+export const includes: <T>(value: T) => (sequence: List<T>) => boolean;
 /** @type {(count: number) => Thunk<number>} */
-declare const countdown: (count: number) => Thunk<number>;
+export const countdown: (count: number) => Thunk<number>;
 /** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-declare const repeat: <T>(v: T) => (c: number) => Thunk<T>;
+export const repeat: <T>(v: T) => (c: number) => Thunk<T>;
 /** @type {<T>(list: List<T>) => List<T>} */
-declare const cycle: <T>(list: List<T>) => List<T>;
-/** @type {<I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
-declare const scan: <I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
-/** @type {<I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-declare const stateScan: <I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
-/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-declare const foldScan: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
-/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-declare const fold: <I, O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
-/** @type {<T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-declare const reduce: <T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
+export const cycle: <T>(list: List<T>) => List<T>;
+/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
+export const scan: <I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
+/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+export const stateScan: <I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+export const foldScan: <I, O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+export const fold: <I, O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
+/** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+export const reduce: <T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
 /** @type {<T>(input: List<T>) => number} */
-declare const length: <T>(input: List<T>) => number;
+export const length: <T>(input: List<T>) => number;
 /** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
-declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
+export const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
 /** @type {<T>(input: List<T>) => List<T>} */
-declare const reverse: <T>(input: List<T>) => List<T>;
+export const reverse: <T>(input: List<T>) => List<T>;
 /** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
-declare const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
-/** @type {<T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-declare const equal: <T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
-import * as Operator from '../function/operator/module.f.mjs';
+export const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
+/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+export const equal: <T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
+export const empty: null;
+export type List<T> = NotLazy<T> | Thunk<T>;
+export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
+export type Empty = null;
+export type Result<T> = Empty | NonEmpty<T>;
+export type Thunk<T> = () => List<T>;
+export type NonEmpty<T> = {
+    readonly first: T;
+    readonly tail: List<T>;
+};
+export type Concat<T> = {
+    readonly head: List<T>;
+    readonly tail: List<T>;
+};
+export type Entry<T> = readonly [number, T];
+import * as function_ from '../function/module.f.mjs';
+import * as operator from '../function/operator/module.f.mjs';

package/types/list/module.f.mjs

@@ -1,7 +1,7 @@
 // @ts-self-types="./module.f.d.mts"
-import function_ from '../function/module.f.mjs'
+import * as function_ from '../function/module.f.mjs'
 const { identity, fn, compose } = function_
-import operator, * as Operator from '../function/operator/module.f.mjs'
+import * as operator from '../function/operator/module.f.mjs'
 const {
     addition,
     logicalNot,
@@ -62,7 +62,7 @@ const fromArray = array => {
 }
 
 /** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
-const concat = head => tail => tail === null ? head : ({ head, tail })
+export const concat = head => tail => tail === null ? head : ({ head, tail })
 
 /** @type {<T>(list: List<T>) => NotLazy<T> } */
 const trampoline = list => {
@@ -71,7 +71,7 @@ const trampoline = list => {
 }
 
 /** @type {<T>(list: List<T>) => Result<T>} */
-const next = head => {
+export const next = head => {
     /** @type {typeof head} */
     let tail = null
     while (true) {
@@ -95,7 +95,7 @@ const next = head => {
 }
 
 /** @type {<T>(list: List<T>) => Iterable<T>} */
-const iterable = list => ({
+export const iterable = list => ({
     *[Symbol.iterator]() {
         let i = list
         while (true) {
@@ -110,7 +110,7 @@ const iterable = list => ({
 const { from } = Array
 
 /** @type {<T>(list: List<T>) => readonly T[]} */
-const toArray = list => {
+export const toArray = list => {
     const u = trampoline(list)
     return u instanceof Array ? u : from(iterable(u))
 }
@@ -126,16 +126,16 @@ const apply = f => input => () => {
 const flatStep = ({ first, tail }) => concat(first)(flat(tail))
 
 /** @type {<T>(list: List<List<T>>) => Thunk<T>} */
-const flat = apply(flatStep)
+export const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
 const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
 
 /** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
-const map = f => apply(mapStep(f))
+export const map = f => apply(mapStep(f))
 
 /** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
-const flatMap = f => compose(map(f))(flat)
+export const flatMap = f => compose(map(f))(flat)
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
 const filterStep = f => ({ first, tail }) => {
@@ -144,7 +144,7 @@ const filterStep = f => ({ first, tail }) => {
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-const filter = f => apply(filterStep(f))
+export const filter = f => apply(filterStep(f))
 
 /** @type {<I, O>(f: (value: I) => O|null) => (n: NonEmpty<I>) => List<O>} */
 const filterMapStep = f => n => {
@@ -153,40 +153,40 @@ const filterMapStep = f => n => {
 }
 
 /** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
-const filterMap = f => apply(filterMapStep(f))
+export const filterMap = f => apply(filterMapStep(f))
 
 /** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
 const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-const takeWhile = f => apply(takeWhileStep(f))
+export const takeWhile = f => apply(takeWhileStep(f))
 
 /** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
 const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null
 
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-const take = n => apply(takeStep(n))
+export const take = n => apply(takeStep(n))
 
 /** @type {<T>(f: (value: T) => boolean) => (ne: NonEmpty<T>) => List<T>} */
 const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne
 
 /** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-const dropWhile = f => apply(dropWhileStep(f))
+export const dropWhile = f => apply(dropWhileStep(f))
 
 /** @type {(n: number) => <T>(ne: NonEmpty<T>) => List<T>} */
 const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne
 
 /** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-const drop = n => apply(dropStep(n))
+export const drop = n => apply(dropStep(n))
 
 /** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
-const first = def => input => {
+export const first = def => input => {
     const ne = next(input)
     return ne === null ? def : ne.first
 }
 
 /** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
-const last = first => tail => {
+export const last = first => tail => {
     /** @typedef {typeof tail extends List<infer T> ? T : never} T */
     /** @type {NonEmpty<typeof first|T>} */
     let i = { first, tail }
@@ -200,61 +200,61 @@ const last = first => tail => {
 }
 
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-const find = def => f => compose(filter(f))(first(def))
+export const find = def => f => compose(filter(f))(first(def))
 
 /** @type {(input: List<boolean>) => boolean} */
-const some = find(false)(identity)
+export const some = find(false)(identity)
 
 /** @type {<T>(input: List<T>) => boolean} */
-const isEmpty = fn(map(() => true))
+export const isEmpty = fn(map(() => true))
     .then(some)
     .then(logicalNot)
     .result
 
-const every = fn(map(logicalNot))
+export const every = fn(map(logicalNot))
     .then(some)
     .then(logicalNot)
     .result
 
 /** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-const includes = value => compose(map(strictEqual(value)))(some)
+export const includes = value => compose(map(strictEqual(value)))(some)
 
 /** @type {(count: number) => Thunk<number>} */
-const countdown = count => () => {
+export const countdown = count => () => {
     if (count <= 0) { return null }
     const first = count - 1
     return { first, tail: countdown(first) }
 }
 
 /** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-const repeat = v => compose(countdown)(map(() => v))
+export const repeat = v => compose(countdown)(map(() => v))
 
 /** @type {<T>(list: List<T>) => List<T>} */
-const cycle = list => () => {
+export const cycle = list => () => {
     const i = next(list)
     return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) }
 }
 
-/** @type {<I, O>(op: Operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
+/** @type {<I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
 const scanStep = op => ne => {
     const [first, newOp] = op(ne.first)
     return { first, tail: scan(newOp)(ne.tail) }
 }
 
-/** @type {<I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
-const scan = op => apply(scanStep(op))
+/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
+export const scan = op => apply(scanStep(op))
 
-/** @type {<I, S, O>(op: Operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-const stateScan = op => compose(stateScanToScan(op))(scan)
+/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+export const stateScan = op => compose(stateScanToScan(op))(scan)
 
-/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-const foldScan = op => compose(foldToScan(op))(scan)
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+export const foldScan = op => compose(foldToScan(op))(scan)
 
-/** @type {<I,O>(op: Operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-const fold = op => init => compose(foldScan(op)(init))(last(init))
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+export const fold = op => init => compose(foldScan(op)(init))(last(init))
 
-/** @type {<T>(op: Operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-const reduce = op => def => compose(scan(reduceToScan(op)))(last(def))
+/** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+export const reduce = op => def => compose(scan(reduceToScan(op)))(last(def))
 
 /** @type {<T>(list: List<T>) => Thunk<number>} */
 const lengthList = list => () => {
@@ -271,7 +271,7 @@ const lengthList = list => () => {
 const sum = reduce(addition)(0)
 
 /** @type {<T>(input: List<T>) => number} */
-const length = compose(lengthList)(sum)
+export const length = compose(lengthList)(sum)
 
 /**
  * @template T
@@ -282,9 +282,9 @@ const length = compose(lengthList)(sum)
 const entryOperator = index => value => [[index, value], index + 1]
 
 /** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
-const entries = input => {
+export const entries = input => {
     /** @typedef {typeof input extends List<infer T> ? T : never} T */
-    /** @type {Operator.StateScan<T, Number, Entry<T>>} */
+    /** @type {operator.StateScan<T, Number, Entry<T>>} */
     const o = entryOperator
     return stateScan(o)(0)(input)
 }
@@ -293,10 +293,10 @@ const entries = input => {
 const reverseOperator = first => tail => ({ first, tail })
 
 /** @type {<T>(input: List<T>) => List<T>} */
-const reverse = fold(reverseOperator)(null)
+export const reverse = fold(reverseOperator)(null)
 
 /** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
-const zip = a => b => () => {
+export const zip = a => b => () => {
     const aResult = next(a)
     if (aResult === null) { return null }
     const bResult = next(b)
@@ -304,9 +304,9 @@ const zip = a => b => () => {
     return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
 }
 
-/** @type {<T>(e: Operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-const equal = e => {
-    /** @typedef {typeof e extends Operator.Equal<infer T> ? T : never} T */
+/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+export const equal = e => {
+    /** @typedef {typeof e extends operator.Equal<infer T> ? T : never} T */
     /** @type {(a: List<T>) => (b: List<T>) => List<boolean>} */
     const f = a => b => () => {
         const [aResult, bResult] = [next(a), next(b)]
@@ -317,73 +317,4 @@ const equal = e => {
     return a => b => every(f(a)(b))
 }
 
-export default {
-    /** @readonly */
-    empty: null,
-    /** @readonly */
-    concat,
-    /** @readonly */
-    next,
-    /** @readonly */
-    iterable,
-    /** @readonly */
-    toArray,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    map,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    filterMap,
-    /** @readonly */
-    takeWhile,
-    /** @readonly */
-    take,
-    /** @readonly */
-    dropWhile,
-    /** @readonly */
-    drop,
-    /** @readonly */
-    first,
-    /** @readonly */
-    last,
-    /** @readonly */
-    find,
-    /** @readonly */
-    some,
-    /** @readonly */
-    every,
-    /** @readonly */
-    isEmpty,
-    /** @readonly */
-    includes,
-    /** @readonly */
-    countdown,
-    /** @readonly */
-    repeat,
-    /** @readonly */
-    cycle,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    stateScan,
-    /** @readonly */
-    foldScan,
-    /** @readonly */
-    fold,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    length,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    reverse,
-    /** @readonly */
-    zip,
-    /** @readonly */
-    equal
-}
+export const empty = null

package/types/list/test.f.mjs

@@ -1,11 +1,11 @@
-import _,  * as T from './module.f.mjs'
-import json, * as Json from '../../json/module.f.mjs'
-import o  from '../object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../object/module.f.mjs'
 const { sort } = o
-import operator from '../function/operator/module.f.mjs'
+import * as operator from '../function/operator/module.f.mjs'
 const { addition, strictEqual, reduceToScan } = operator
 
-/** @type {(sequence: T.List<Json.Unknown>) => string} */
+/** @type {(sequence: _.List<json.Unknown>) => string} */
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 const stringifyTest = () => {
@@ -197,7 +197,7 @@ const stress = () => ({
         if (first !== n - 1) { throw first }
     },
     concatBack: () => {
-        /** @type {T.List<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 20_000_000 is too much
         // 10_000_000 is too much for Deno 1
@@ -207,7 +207,7 @@ const stress = () => ({
         const r = _.toArray(sequence)
     },
     flatToArray: () => {
-        /** @type {T.List<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
@@ -216,7 +216,7 @@ const stress = () => ({
         const r = _.toArray(sequence)
     },
     flatNext: () => {
-        /** @type {T.List<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
@@ -225,7 +225,7 @@ const stress = () => ({
         const a = _.next(sequence)
     },
     concatFront: () => {
-        /** @type {T.List<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
@@ -234,7 +234,7 @@ const stress = () => ({
         const a = _.next(sequence)
     },
     flatFront: () => {
-        /** @type {T.List<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {

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

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