functionalscript 0.1.608 → 0.2.0

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)

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

@@ -1,13 +1,7 @@
-declare namespace _default {
-    export { sum };
-    export { min };
-    export { max };
-    export { cmp };
-}
-export default _default;
-declare const sum: (input: import("../list/module.f.mjs").List<number>) => number;
-declare const min: (input: import("../list/module.f.mjs").List<number>) => number | null;
-declare const max: (input: import("../list/module.f.mjs").List<number>) => number | null;
-/** @type {(a: number) => (b: number) => Compare.Sign} */
-declare const cmp: (a: number) => (b: number) => Compare.Sign;
-import * as Compare from '../function/compare/module.f.mjs';
+export const sum: (input: list.List<number>) => number;
+export const min: (input: list.List<number>) => number | null;
+export const max: (input: list.List<number>) => number | null;
+/** @type {(a: number) => (b: number) => compare.Sign} */
+export const cmp: (a: number) => (b: number) => compare.Sign;
+import * as list from '../list/module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';

package/types/number/module.f.mjs

@@ -1,27 +1,16 @@
 // @ts-self-types="./module.f.d.mts"
-import list from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { reduce } = list
-import operator from '../function/operator/module.f.mjs'
+import * as operator from '../function/operator/module.f.mjs'
 const { addition, min: minOp, max: maxOp } = operator
-import compare, * as Compare from '../function/compare/module.f.mjs'
+import * as compare from '../function/compare/module.f.mjs'
 const { unsafeCmp } = compare
 
-const sum = reduce(addition)(0)
+export const sum = reduce(addition)(0)
 
-const min = reduce(minOp)(null)
+export const min = reduce(minOp)(null)
 
-const max = reduce(maxOp)(null)
+export const max = reduce(maxOp)(null)
 
-/** @type {(a: number) => (b: number) => Compare.Sign} */
-const cmp = unsafeCmp
-
-export default {
-    /** @readonly */
-    sum,
-    /** @readonly */
-    min,
-    /** @readonly */
-    max,
-    /** @readonly */
-    cmp,
-}
+/** @type {(a: number) => (b: number) => compare.Sign} */
+export const cmp = unsafeCmp

package/types/number/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { sum, min, max, cmp } = _
 
 export default {

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

@@ -1,12 +1,3 @@
-declare namespace _default {
-    export { at };
-    export { sort };
-    export { fromEntries };
-    export { fromMap };
-}
-export default _default;
-export type Map<T> = { readonly [k in string]: T; };
-export type Entry<T> = readonly [string, T];
 /**
  * @template T
  * @typedef {{
@@ -18,12 +9,14 @@ export type Entry<T> = readonly [string, T];
  * @typedef {readonly[string, T]} Entry
  */
 /** @type {(name: string) => <T>(object: Map<T>) => T|null} */
-declare const at: (name: string) => <T>(object: Map<T>) => T | null;
-/** @type {<T>(e: List.List<Entry<T>>) => List.List<Entry<T>>} */
-declare const sort: <T>(e: List.List<Entry<T>>) => List.List<Entry<T>>;
-/** @type {<T>(e: List.List<Entry<T>>) => Map<T>} */
-declare const fromEntries: <T>(e: List.List<Entry<T>>) => Map<T>;
-/** @type {<T>(m: BTMap.Map<T>) => Map<T>} */
-declare const fromMap: <T>(m: BTMap.Map<T>) => Map<T>;
-import * as List from '../list/module.f.mjs';
-import * as BTMap from '../map/module.f.mjs';
+export const at: (name: string) => <T>(object: Map<T>) => T | null;
+/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
+export const sort: <T>(e: list.List<Entry<T>>) => list.List<Entry<T>>;
+/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
+export const fromEntries: <T>(e: list.List<Entry<T>>) => Map<T>;
+/** @type {<T>(m: btMap.Map<T>) => Map<T>} */
+export const fromMap: <T>(m: btMap.Map<T>) => Map<T>;
+export type Map<T> = { readonly [k in string]: T; };
+export type Entry<T> = readonly [string, T];
+import * as list from '../list/module.f.mjs';
+import * as btMap from '../map/module.f.mjs';

package/types/object/module.f.mjs

@@ -1,7 +1,7 @@
 // @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 { iterable } = list
-import btMap, * as BTMap from '../map/module.f.mjs'
+import * as btMap from '../map/module.f.mjs'
 const { entries: mapEntries, fromEntries: mapFromEntries } = btMap
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
 
@@ -18,27 +18,16 @@ const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
  */
 
 /** @type {(name: string) => <T>(object: Map<T>) => T|null} */
-const at = name => object => {
+export const at = name => object => {
     const r = getOwnPropertyDescriptor(object, name)
     return r === void 0 ? null : r.value
 }
 
-/** @type {<T>(e: List.List<Entry<T>>) => List.List<Entry<T>>} */
-const sort = e => mapEntries(mapFromEntries(e))
+/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
+export const sort = e => mapEntries(mapFromEntries(e))
 
-/** @type {<T>(e: List.List<Entry<T>>) => Map<T>} */
-const fromEntries = e => objectFromEntries(iterable(e))
+/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
+export const fromEntries = e => objectFromEntries(iterable(e))
 
-/** @type {<T>(m: BTMap.Map<T>) => Map<T>} */
-const fromMap = m => fromEntries(mapEntries(m))
-
-export default {
-    /** @readonly */
-    at,
-    /** @readonly */
-    sort,
-    /** @readonly */
-    fromEntries,
-    /** @readonly */
-    fromMap,
-}
+/** @type {<T>(m: btMap.Map<T>) => Map<T>} */
+export const fromMap = m => fromEntries(mapEntries(m))

package/types/object/test.f.mjs

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

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

@@ -1,11 +1,6 @@
-declare namespace _default {
-    export { contains };
-    export { one };
-}
-export default _default;
-export type Range = readonly [number, number];
 /** @typedef {readonly[number,number]} Range */
 /** @type {(range: Range) => (i: number) => boolean} */
-declare const contains: (range: Range) => (i: number) => boolean;
+export const contains: (range: Range) => (i: number) => boolean;
 /** @type {(i: number) => Range} */
-declare const one: (i: number) => Range;
+export const one: (i: number) => Range;
+export type Range = readonly [number, number];

package/types/range/module.f.mjs

@@ -2,14 +2,7 @@
 /** @typedef {readonly[number,number]} Range */
 
 /** @type {(range: Range) => (i: number) => boolean} */
-const contains = ([b, e]) => i => b <= i && i <= e
+export const contains = ([b, e]) => i => b <= i && i <= e
 
 /** @type {(i: number) => Range} */
-const one = a => [a, a]
-
-export default {
-    /** @readonly */
-    contains,
-    /** @readonly */
-    one,
-}
+export const one = a => [a, a]

package/types/range/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 export default () => {
     if (!_.contains([0, 5])(1)) { throw 1 }

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

@@ -1,11 +1,11 @@
-declare namespace _default {
-    export { merge };
-    export { get };
-    export { fromRange };
-}
-export default _default;
+/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+export const merge: <T>(op: Operators<T>) => RangeMerge<T>;
+/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
+export const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
+/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
+export const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
 export type Entry<T> = [T, number];
-export type RangeMap<T> = SortedList.SortedList<Entry<T>>;
+export type RangeMap<T> = sortedList.SortedList<Entry<T>>;
 export type RangeMapArray<T> = readonly Entry<T>[];
 export type Operators<T> = {
     readonly union: O.Reduce<T>;
@@ -13,13 +13,7 @@ export type Operators<T> = {
 };
 export type RangeState<T> = Option.Nullable<Entry<T>>;
 export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
-/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
-/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
-declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
-/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
-declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
-import * as SortedList from '../sorted_list/module.f.mjs';
+import * as Range from '../range/module.f.mjs';
+import * as sortedList from '../sorted_list/module.f.mjs';
 import * as O from '../function/operator/module.f.mjs';
 import * as Option from '../nullable/module.f.mjs';
-import * as Range from '../range/module.f.mjs';

package/types/range_map/module.f.mjs

@@ -1,10 +1,10 @@
 // @ts-self-types="./module.f.d.mts"
-import sortedList, * as SortedList from '../sorted_list/module.f.mjs'
+import * as sortedList from '../sorted_list/module.f.mjs'
 const { genericMerge } = sortedList
-import list from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { next } = list
 import * as Option from '../nullable/module.f.mjs'
-import number from '../number/module.f.mjs'
+import * as number from '../number/module.f.mjs'
 const { cmp } = number
 import * as O from '../function/operator/module.f.mjs'
 import * as Range from '../range/module.f.mjs'
@@ -16,7 +16,7 @@ import * as Range from '../range/module.f.mjs'
 
 /**
  * @template T
- * @typedef {SortedList.SortedList<Entry<T>>} RangeMap
+ * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
  */
 
 /**
@@ -42,7 +42,7 @@ import * as Range from '../range/module.f.mjs'
  * @typedef {O.Reduce<RangeMap<T>>} RangeMerge
  */
 
-/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => SortedList.ReduceOp<Entry<T>, RangeState<T>>} */
+/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>} */
 const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax)
     const min = sign === 1 ? bMax : aMax
@@ -51,7 +51,7 @@ const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) =
     return [newState, sign, [u, min]]
 }
 
-/** @type {<T>(equal: O.Equal<T>) => SortedList.TailReduce<Entry<T>, RangeState<T>>} */
+/** @type {<T>(equal: O.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
 const tailReduce = equal => state => tail => {
     if (state === null) { return tail }
     const tailResult = next(tail)
@@ -61,10 +61,10 @@ const tailReduce = equal => state => tail => {
 }
 
 /** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null)
+export const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null)
 
 /** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
-const get = def => value => rm => {
+export const get = def => value => rm => {
     const len = rm.length
     let b = 0
     let e = len - 1
@@ -81,13 +81,4 @@ const get = def => value => rm => {
 }
 
 /** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
-const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]]
-
-export default {
-    /** @readonly */
-    merge,
-    /** @readonly */
-    get,
-    /** @readonly */
-    fromRange,
-}
+export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]]