functionalscript 0.1.609 → 0.2.1

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.mjs

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

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.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.mjs

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

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

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

package/types/function/test.f.mjs

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