functionalscript 0.0.592 → 0.1.594

package/types/btree/{test.f.cjs → test.f.mjs}

@@ -1,26 +1,29 @@
-const btree = require('./types/module.f.cjs')
-const { values } = require('./module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../object/module.f.cjs')
-const { cmp } = require('../string/module.f.cjs')
-const list = require('../list/module.f.cjs')
-const s = require('./set/module.f.cjs')
-const f = require('./find/module.f.cjs')
+import * as btreeT from './types/module.f.mjs'
+import _ from './module.f.mjs'
+const { values } = _
+import json, * as jsonT from '../../json/module.f.mjs'
+import o from '../object/module.f.mjs'
+const { sort } = o
+import 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'
 
-require('./find/test.f.cjs')
-require('./set/test.f.cjs')
-require('./remove/test.f.cjs')
+// require('./find/test.f.mjs')
+// require('./set/test.f.mjs')
+// require('./remove/test.f.mjs')
 
 const jsonStr = json.stringify(sort)
 
-/** @type {(sequence: list.List<json.Unknown>) => string} */
+/** @type {(sequence: List.List<jsonT.Unknown>) => string} */
 const stringify = sequence => jsonStr(list.toArray(sequence))
 
-/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+/** @type {(node: btreeT.Node<string>) => (value: string) => btreeT.Node<string>} */
 const set = node => value => s.set(cmp(value))(() => value)(node)
 
 const valueTest1 = () => {
-    /** @type {btree.Node<string>} */
+    /** @type {btreeT.Node<string>} */
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
@@ -32,7 +35,7 @@ const valueTest1 = () => {
 }
 
 const valuesTest2 = () => {
-    /** @type {btree.Node<string>} */
+    /** @type {btreeT.Node<string>} */
     let _map = ['1']
     for(let i = 2; i <= 10; i++)
         _map = set(_map)((i*i).toString())
@@ -41,7 +44,7 @@ const valuesTest2 = () => {
 }
 
 const findTrue = () => {
-    /** @type {btree.Node<string>} */
+    /** @type {btreeT.Node<string>} */
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
@@ -50,7 +53,7 @@ const findTrue = () => {
 }
 
 const find = () => {
-    /** @type {btree.Node<string>} */
+    /** @type {btreeT.Node<string>} */
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
@@ -59,7 +62,7 @@ const find = () => {
 }
 
 const test = () => {
-    /** @type {btree.Node<string>} */
+    /** @type {btreeT.Node<string>} */
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
@@ -68,7 +71,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)
@@ -76,7 +79,7 @@ const test = () => {
     }
 }
 
-module.exports = {
+export default {
     valueTest1,
     valuesTest2,
     findTrue,

package/types/btree/types/{module.f.cjs → module.f.mjs}

@@ -61,4 +61,4 @@
  * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
  */
 
-module.exports = {}
+export default {}

package/types/byte_set/{module.f.cjs → module.f.mjs}

@@ -1,7 +1,8 @@
-const { fn, compose } = require('../function/module.f.cjs')
-const rangeMap = require('../range_map/module.f.cjs')
-const sortedSet = require('../sorted_set/module.f.cjs')
-const list = require('../list/module.f.cjs')
+import f from '../function/module.f.mjs'
+const { fn, compose } = f
+import * as RangeMap from '../range_map/module.f.mjs'
+import sortedSet, * as SortedSet from '../sorted_set/module.f.mjs'
+import list from '../list/module.f.mjs'
 const { reverse, countdown, flat, map } = list
 
 /** @typedef {bigint} ByteSet */
@@ -48,17 +49,17 @@ const unset = n => s => difference(s)(one(n))
 
 const counter = reverse(countdown(256))
 
-/** @type {(n: ByteSet) => (s: string) => (i: number) => rangeMap.RangeMap<sortedSet.SortedSet<string>>} */
+/** @type {(n: ByteSet) => (s: string) => (i: number) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
 const toRangeMapOp = n => s => i => {
     const current = has(i + 1)(n)
     const prev = has(i)(n)
     return current === prev ? null : [[prev ? [s] : [], i]]
 }
 
-/** @type {(n: ByteSet) => (s: string) => rangeMap.RangeMap<sortedSet.SortedSet<string>>} */
+/** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
 const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter))
 
-module.exports = {
+export default {
     /** @readonly */
     empty,
     /** @readonly */

package/types/byte_set/{test.f.cjs → test.f.mjs}

@@ -1,13 +1,14 @@
-const _ = require('./module.f.cjs')
-const { every, countdown, map } = require('../list/module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../object/module.f.cjs')
-const { toArray } = require('../list/module.f.cjs')
+import _ from './module.f.mjs'
+import list from '../list/module.f.mjs'
+const { every, countdown, map, toArray } = list
+import json, * as jsonT from '../../json/module.f.mjs'
+import o from '../object/module.f.mjs'
+const { sort } = o
 
-/** @type {(a: readonly json.Unknown[]) => string} */
+/** @type {(a: readonly jsonT.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
-module.exports = {
+export default {
     has: [
         () => {
             if (_.has(0)(_.empty)) { throw _.empty }

package/types/function/compare/{module.f.cjs → module.f.mjs}

@@ -1,4 +1,4 @@
-const array = require('../../array/module.f.cjs')
+import * as array from '../../array/module.f.mjs'
 
 /** @typedef {array.Index3} Index3 */
 /** @typedef {array.Index5} Index5 */
@@ -27,7 +27,7 @@ const index5 = cmp => ([v0, v1]) => {
 /** @type {<T>(a: T) => (b: T) => Sign} */
 const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0
 
-module.exports = {
+export default {
     /** @readonly */
     unsafeCmp,
     /** @readonly */

package/types/function/compare/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,7 @@
-const { unsafeCmp } = require('./module.f.cjs')
+import _ from './module.f.mjs'
+const { unsafeCmp } = _
 
-module.exports = () => {
+export default () => {
     const result = unsafeCmp(true)(false)
     if (result !== 1) { throw result }
 }

package/types/function/{module.f.cjs → module.f.mjs}

@@ -31,11 +31,7 @@ const fn = result => ({
     then: g => fn(compose(result)(g))
 })
 
-module.exports = {
-    /** @readonly */
-    compare: require('./compare/module.f.cjs'),
-    /** @readonly */
-    operator: require('./operator/module.f.cjs'),
+export default {
     /** @readonly */
     identity,
     /** @readonly */

package/types/function/operator/{module.f.cjs → module.f.mjs}

@@ -76,7 +76,7 @@ const increment = addition(1)
 
 const counter = () => increment
 
-module.exports = {
+export default {
     /** @readonly */
     join,
     /** @readonly */

package/types/function/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,8 @@
-const { fn } = require('./module.f.cjs')
+import _ from './module.f.mjs'
 
-module.exports = () => {
+const { fn } = _
+
+export default () => {
     /** @type {(x: string) => readonly[string]} */
     const f = x => [x]
     /** @type {(x: readonly[string]) => readonly[number]} */

package/types/list/{module.f.cjs → module.f.mjs}

@@ -1,6 +1,6 @@
-const function_ = require('../function/module.f.cjs')
+import function_ from '../function/module.f.mjs'
 const { identity, fn, compose } = function_
-const operator = require('../function/operator/module.f.cjs')
+import operator, * as Operator from '../function/operator/module.f.mjs'
 const {
     addition,
     logicalNot,
@@ -234,25 +234,25 @@ const cycle = 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>} */
+/** @type {<I, O>(op: Operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
 const scan = op => apply(scanStep(op))
 
-/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+/** @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,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>) => Thunk<O>} */
 const foldScan = op => compose(foldToScan(op))(scan)
 
-/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+/** @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 {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+/** @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>(list: List<T>) => Thunk<number>} */
@@ -283,7 +283,7 @@ const entryOperator = index => value => [[index, value], index + 1]
 /** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
 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)
 }
@@ -303,9 +303,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} */
+/** @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 */
+    /** @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)]
@@ -316,7 +316,7 @@ const equal = e => {
     return a => b => every(f(a)(b))
 }
 
-module.exports = {
+export default {
     /** @readonly */
     empty: null,
     /** @readonly */

package/types/list/{test.f.cjs → test.f.mjs}

@@ -1,9 +1,11 @@
-const _ = require('./module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../object/module.f.cjs')
-const { addition, strictEqual, reduceToScan } = require('../function/operator/module.f.cjs')
+import _,  * as T from './module.f.mjs'
+import json, * as Json from '../../json/module.f.mjs'
+import o  from '../object/module.f.mjs'
+const { sort } = o
+import operator from '../function/operator/module.f.mjs'
+const { addition, strictEqual, reduceToScan } = operator
 
-/** @type {(sequence: _.List<json.Unknown>) => string} */
+/** @type {(sequence: T.List<Json.Unknown>) => string} */
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 const stringifyTest = () => {
@@ -195,7 +197,7 @@ const stress = () => ({
         if (first !== n - 1) { throw first }
     },
     concatBack: () => {
-        /** @type {_.List<number>} */
+        /** @type {T.List<number>} */
         let sequence = []
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
@@ -204,7 +206,7 @@ const stress = () => ({
         const r = _.toArray(sequence)
     },
     flatToArray: () => {
-        /** @type {_.List<number>} */
+        /** @type {T.List<number>} */
         let sequence = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
@@ -213,7 +215,7 @@ const stress = () => ({
         const r = _.toArray(sequence)
     },
     flatNext: () => {
-        /** @type {_.List<number>} */
+        /** @type {T.List<number>} */
         let sequence = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
@@ -222,7 +224,7 @@ const stress = () => ({
         const a = _.next(sequence)
     },
     concatFront: () => {
-        /** @type {_.List<number>} */
+        /** @type {T.List<number>} */
         let sequence = []
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
@@ -231,7 +233,7 @@ const stress = () => ({
         const a = _.next(sequence)
     },
     flatFront: () => {
-        /** @type {_.List<number>} */
+        /** @type {T.List<number>} */
         let sequence = []
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {
@@ -264,7 +266,7 @@ const stress = () => ({
 
 })
 
-module.exports = {
+export default {
     stringifyTest,
     cycle,
     countdown,

package/types/map/{module.f.cjs → module.f.mjs}

@@ -1,21 +1,24 @@
-const btreeTypes = require('../btree/types/module.f.cjs')
-const {
-    values,
-    find: { value, find },
-    set: { set },
-    remove: { remove: btreeRemove }
-} = require("../btree/module.f.cjs")
-const compare = require('../function/compare/module.f.cjs')
-const { cmp } = require('../string/module.f.cjs')
-const list = require('../list/module.f.cjs')
+import * as btreeTypes from '../btree/types/module.f.mjs'
+import btf from '../btree/find/module.f.mjs'
+const { value, find } = btf
+import bts from '../btree/set/module.f.mjs'
+const { set } = bts
+import btr from '../btree/remove/module.f.mjs'
+const { remove: btreeRemove } = btr
+import bt from '../btree/module.f.mjs'
+const { values } = bt
+import compare, * as Compare from '../function/compare/module.f.mjs'
+import s from '../string/module.f.mjs'
+const { cmp } = s
+import list, * as List from '../list/module.f.mjs'
 const { fold } = list
-const operator = require('../function/operator/module.f.cjs')
+import operator, * as Operator from '../function/operator/module.f.mjs'
 
-/** @typedef {compare.Sign} Sign */
+/** @typedef {Compare.Sign} Sign */
 
 /**
  * @template T
- * @typedef {compare.Compare<T>} Cmp
+ * @typedef {Compare.Compare<T>} Cmp
  */
 
 /**
@@ -38,11 +41,11 @@ const at = name => map => {
     return result === null ? null : result[1]
 }
 
-/** @type {<T>(reduce: operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>} */
+/** @type {<T>(reduce: Operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>} */
 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>} */
+/** @type {<T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
 const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value])
 
 /** @type {<T>(a: T) => (b: T) => T} */
@@ -51,16 +54,16 @@ const replace = () => b => b
 /** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
 const setReplace = name => value => setReduceEntry(replace)([name, value])
 
-/** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */
+/** @type {<T>(map: Map<T>) => List.List<Entry<T>>} */
 const entries = values
 
-/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
+/** @type {<T>(entries: List.List<Entry<T>>) => Map<T>} */
 const fromEntries = fold(setReduceEntry(replace))(null)
 
 /** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
 const remove = name => btreeRemove(keyCmp(name))
 
-module.exports = {
+export default {
     /** @readonly */
     empty: null,
     /** @readonly */

package/types/map/{test.f.cjs → test.f.mjs}

@@ -1,7 +1,8 @@
-const { at, setReplace, setReduce, empty, entries, remove } = require('./module.f.cjs')
-const seq = require('../list/module.f.cjs')
+import _ from './module.f.mjs'
+const { at, setReplace, setReduce, empty, entries, remove } = _
+import seq from '../list/module.f.mjs'
 
-module.exports = {
+export default {
     main: [
         () => {
             let m = setReplace('a')(1)(null)
@@ -57,7 +58,7 @@ module.exports = {
         },
     ],
     stress: () => {
-        /** @type {import('./module.f.cjs').Map<number>} */
+        /** @type {import('./module.f.mjs').Map<number>} */
         let m = empty
         for (let i = 0; i < 100_000; ++i) {
             m = setReplace((i * i).toString())(i)(m)

package/types/nibble_set/{module.f.cjs → module.f.mjs}

@@ -26,7 +26,7 @@ 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)
 
-module.exports = {
+export default {
     /** @readonly */
     empty,
     /** @readonly */

package/types/nibble_set/{test.f.cjs → test.f.mjs}

@@ -1,7 +1,8 @@
-const { every, map, countdown } = require('../list/module.f.cjs')
-const _ = require('./module.f.cjs')
+import list from '../list/module.f.mjs'
+const { every, map, countdown } = list
+import _ from './module.f.mjs'
 
-module.exports = {
+export default {
     has: () => {
         if (_.has(0)(_.empty)) { throw _.empty }
         if (_.has(1)(_.empty)) { throw _.empty }

package/types/nullable/{module.f.cjs → module.f.mjs}

@@ -9,7 +9,7 @@ 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)
 
-module.exports = {
+export default {
     /** @readonly */
     map,
     /** @readonly */

package/types/nullable/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,6 @@
-const _ = require('./module.f.cjs')
+import _ from './module.f.mjs'
 
-module.exports = () => {
+export default () => {
     const optionSq = _.map(v => v * v)
     const sq3 = optionSq(3)
     if (sq3 !== 9) { throw sq3 }

package/types/number/module.f.mjs

@@ -0,0 +1,26 @@
+import list from '../list/module.f.mjs'
+const { reduce } = list
+import operator from '../function/operator/module.f.mjs'
+const { addition, min: minOp, max: maxOp } = operator
+import compare, * as Compare from '../function/compare/module.f.mjs'
+const { unsafeCmp } = compare
+
+const sum = reduce(addition)(0)
+
+const min = reduce(minOp)(null)
+
+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,
+}

package/types/number/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,7 @@
-const { sum, min, max, cmp } = require('./module.f.cjs')
+import _ from './module.f.mjs'
+const { sum, min, max, cmp } = _
 
-module.exports = {
+export default {
     sum: () => {
         const result = sum([2, 3, 4, 5])
         if (result !== 14) { throw result }

package/types/object/{module.f.cjs → module.f.mjs}

@@ -1,6 +1,6 @@
-const list = require('../list/module.f.cjs')
+import list, * as List from '../list/module.f.mjs'
 const { iterable } = list
-const map = require('../map/module.f.cjs')
+import map, * as Map from '../map/module.f.mjs'
 const { entries: mapEntries, fromEntries: mapFromEntries } = map
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
 
@@ -22,16 +22,16 @@ const at = name => object => {
     return r === void 0 ? null : r.value
 }
 
-/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
+/** @type {<T>(e: List.List<Entry<T>>) => List.List<Entry<T>>} */
 const sort = e => mapEntries(mapFromEntries(e))
 
-/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
+/** @type {<T>(e: List.List<Entry<T>>) => Map<T>} */
 const fromEntries = e => objectFromEntries(iterable(e))
 
-/** @type {<T>(m: map.Map<T>) => Map<T>} */
+/** @type {<T>(m: Map.Map<T>) => Map<T>} */
 const fromMap = m => fromEntries(mapEntries(m))
 
-module.exports = {
+export default {
     /** @readonly */
     at,
     /** @readonly */

package/types/object/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,6 @@
-const _ = require('./module.f.cjs')
+import _ from './module.f.mjs'
 
-module.exports = {
+export default {
     ctor: () => {
         const a = {}
         const value = _.at('constructor')(a)

package/types/range/{module.f.cjs → module.f.mjs}

@@ -6,7 +6,7 @@ const contains = ([b, e]) => i => b <= i && i <= e
 /** @type {(i: number) => Range} */
 const one = a => [a, a]
 
-module.exports = {
+export default {
     /** @readonly */
     contains,
     /** @readonly */

package/types/range/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,6 @@
-const _ = require('./module.f.cjs')
+import _ from './module.f.mjs'
 
-module.exports = () => {
+export default () => {
     if (!_.contains([0, 5])(1)) { throw 1 }
     if (!_.contains([0, 5])(0)) { throw 0 }
     if (!_.contains([0, 5])(5)) { throw 5 }