functionalscript 0.1.609 → 0.2.0

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';

package/types/map/module.f.mjs

@@ -1,17 +1,17 @@
 // @ts-self-types="./module.f.d.mts"
 import * as BtreeTypes from '../btree/types/module.f.mjs'
-import btf from '../btree/find/module.f.mjs'
+import * as btf from '../btree/find/module.f.mjs'
 const { value, find } = btf
-import bts from '../btree/set/module.f.mjs'
+import * as bts from '../btree/set/module.f.mjs'
 const { set } = bts
-import btr from '../btree/remove/module.f.mjs'
+import * as btr from '../btree/remove/module.f.mjs'
 const { remove: btreeRemove } = btr
-import bt from '../btree/module.f.mjs'
+import * as bt from '../btree/module.f.mjs'
 const { values } = bt
 import * as Compare from '../function/compare/module.f.mjs'
-import s from '../string/module.f.mjs'
+import * as s from '../string/module.f.mjs'
 const { cmp } = s
-import list, * as List from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { fold } = list
 import * as Operator from '../function/operator/module.f.mjs'
 
@@ -36,7 +36,7 @@ import * as Operator from '../function/operator/module.f.mjs'
 const keyCmp = a => ([b]) => cmp(a)(b)
 
 /** @type {(name: string) => <T>(map: Map<T>) => T|null} */
-const at = name => map => {
+export const at = name => map => {
     if (map === null) { return null }
     const result = value(find(keyCmp(name))(map).first)
     return result === null ? null : result[1]
@@ -47,36 +47,21 @@ const setReduceEntry = reduce => entry =>
     set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])])
 
 /** @type {<T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
-const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value])
+export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value])
 
 /** @type {<T>(a: T) => (b: T) => T} */
 const replace = () => b => b
 
 /** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
-const setReplace = name => value => setReduceEntry(replace)([name, value])
+export const setReplace = name => value => setReduceEntry(replace)([name, value])
 
-/** @type {<T>(map: Map<T>) => List.List<Entry<T>>} */
-const entries = values
+/** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */
+export const entries = values
 
-/** @type {<T>(entries: List.List<Entry<T>>) => Map<T>} */
-const fromEntries = fold(setReduceEntry(replace))(null)
+/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
+export const fromEntries = fold(setReduceEntry(replace))(null)
 
 /** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
-const remove = name => btreeRemove(keyCmp(name))
+export const remove = name => btreeRemove(keyCmp(name))
 
-export default {
-    /** @readonly */
-    empty: null,
-    /** @readonly */
-    at,
-    /** @readonly */
-    setReduce,
-    /** @readonly */
-    setReplace,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    fromEntries,
-    /** @readonly */
-    remove,
-}
+export const empty = null

package/types/map/test.f.mjs

@@ -1,6 +1,6 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { at, setReplace, setReduce, empty, entries, remove } = _
-import seq from '../list/module.f.mjs'
+import * as seq from '../list/module.f.mjs'
 
 export default {
     main: [

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

@@ -1,26 +1,16 @@
-declare namespace _default {
-    export { empty };
-    export { universe };
-    export { has };
-    export { complement };
-    export { set };
-    export { unset };
-    export { setRange };
-}
-export default _default;
-export type NibbleSet = number;
-export type Nibble = number;
 /** @typedef {number} NibbleSet */
 /** @typedef {number} Nibble */
-declare const empty: 0;
-declare const universe: 65535;
+export const empty: 0;
+export const universe: 65535;
 /** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
-declare const has: (n: Nibble) => (s: NibbleSet) => boolean;
-/** @type {(n: NibbleSet) => NibbleSet} */
-declare const complement: (n: NibbleSet) => NibbleSet;
+export const has: (n: Nibble) => (s: NibbleSet) => boolean;
 /** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
-declare const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+export const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(n: NibbleSet) => NibbleSet} */
+export const complement: (n: NibbleSet) => NibbleSet;
 /** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
-declare const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+export const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
 /** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
-declare const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;
+export const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;
+export type NibbleSet = number;
+export type Nibble = number;

package/types/nibble_set/module.f.mjs

@@ -2,44 +2,27 @@
 /** @typedef {number} NibbleSet */
 /** @typedef {number} Nibble */
 
-const empty = 0
+export const empty = 0
 
-const universe = 0xFFFF
+export const universe = 0xFFFF
 
 /** @type {(n: Nibble) => NibbleSet} */
 const one = n => 1 << n
 
 /** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
-const has = n => s => ((s >> n) & 1) === 1
+export const has = n => s => ((s >> n) & 1) === 1
 
 /** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
-const set = n => s => s | one(n)
+export const set = n => s => s | one(n)
 
 /** @type {(n: NibbleSet) => NibbleSet} */
-const complement = s => universe ^ s
+export const complement = s => universe ^ s
 
 /** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
-const unset = n => s => s & complement(one(n))
+export const unset = n => s => s & complement(one(n))
 
 /** @type {(r: readonly[number, number]) => NibbleSet} */
 const range = ([a, b]) => one(b - a + 1) - 1 << a
 
 /** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
-const setRange = r => s => s | range(r)
-
-export default {
-    /** @readonly */
-    empty,
-    /** @readonly */
-    universe,
-    /** @readonly */
-    has,
-    /** @readonly */
-    complement,
-    /** @readonly */
-    set,
-    /** @readonly */
-    unset,
-    /** @readonly */
-    setRange,
-}
+export const setRange = r => s => s | range(r)

package/types/nibble_set/test.f.mjs

@@ -1,6 +1,6 @@
-import list from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { every, map, countdown } = list
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 export default {
     has: () => {

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

@@ -1,14 +1,9 @@
-declare namespace _default {
-    export { map };
-    export { match };
-}
-export default _default;
-export type Nullable<T> = T | null;
 /**
  * @template T
  * @typedef {T|null} Nullable
  */
 /** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
-declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
+export const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
 /** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
-declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
+export const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
+export type Nullable<T> = T | null;

package/types/nullable/module.f.mjs

@@ -5,14 +5,7 @@
  */
 
 /** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
-const map = f => value => value === null ? null : f(value)
+export const map = f => value => value === null ? null : f(value)
 
 /** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
-const match = f => none => value => value === null ? none() : f(value)
-
-export default {
-    /** @readonly */
-    map,
-    /** @readonly */
-    match,
-}
+export const match = f => none => value => value === null ? none() : f(value)

package/types/nullable/test.f.mjs

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