functionalscript 0.0.390 → 0.0.393

package/test.f.cjs

@@ -1,6 +1,8 @@
 const i = require('./module.f.cjs')
 
 require('./types/list/test.f.cjs')
+require('./types/number/test.f.cjs')
+require('./types/bigint/module.f.cjs')
 require('./types/array/test.f.cjs')
 require('./types/btree/test.f.cjs')
 require('./sha2/test.f.cjs')
@@ -12,7 +14,7 @@ require('./commonjs/package/dependencies/test.f.cjs')
 require('./commonjs/package/test.f.cjs')
 require('./commonjs/path/test.f.cjs')
 require('./types/function/compare/test.f.cjs')
-require('./types/stringset/test.f.cjs')
+require('./types/string_set/test.f.cjs')
 require('./types/option/test.f.cjs')
 require('./commonjs/build/test.f.cjs')
 require('./types/range/test.f.cjs')

package/text/encoding/module.f.cjs

@@ -55,10 +55,8 @@ const codePointToUtf16 = input =>
     return [input & 0xffff]
 }
 
-/** @type {(input: list.List<number>) => list.List<ByteResult>} */
 const codePointListToUtf8List = flatMap(codePointToUtf8)
 
-/** @type {(input: list.List<i32>) => list.List<u16>} */
 const codePointListToUtf16List = flatMap(codePointToUtf16)
 
 /** @type {operator.StateScan<number, Utf8State, list.List<CodePointResult>>} */

package/text/module.f.cjs

@@ -1,4 +1,5 @@
 const list = require('../types/list/module.f.cjs')
+const { flatMap } = list
 
 /** @typedef {ItemThunk|ItemArray} Block */
 
@@ -15,7 +16,7 @@ const flat = indent => {
     const f = prefix => {
         /** @type {(item: Item) => list.List<string>} */
         const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
-        return list.flatMap(g)
+        return flatMap(g)
     }
 
     return f('')

package/types/array/module.f.cjs

@@ -1,4 +1,5 @@
 const option = require('../option/module.f.cjs')
+const { map } = option
 
 /**
  * @template T
@@ -97,7 +98,7 @@ const splitFirst = a => {
     /** @typedef {typeof a[0]} T*/
     /** @type {(_: T) => readonly[T, readonly T[]]} */
     const split = first => [first, uncheckTail(a)]
-    return option.map(split)(a[0])
+    return map(split)(a[0])
 }
 
 /** @type {<T>(_: readonly T[]) => readonly T[]|undefined} */

package/types/bigint/module.f.cjs

@@ -0,0 +1,10 @@
+const { fold } = require('../list/module.f.cjs')
+
+/** @type {(a: bigint) => (b: bigint) => bigint} */
+const addition = a => b => a + b
+
+const sum = fold(addition)(0n)
+
+module.exports = {
+    sum,
+}

package/types/bigint/test.f.cjs

@@ -0,0 +1,8 @@
+const { sum } = require('./module.f.cjs')
+
+{
+    const result = sum([2n, 3n, 4n, 5n])
+    if (result !== 14n) { throw result }
+}
+
+module.exports = {}

package/types/btree/find/module.f.cjs

@@ -1,6 +1,7 @@
 const _ = require('../types/module.f.cjs')
 const list = require('../../list/module.f.cjs')
 const cmp = require('../../function/compare/module.f.cjs')
+const { index3, index5 } = cmp
 const array = require('../../array/module.f.cjs')
 
 /**
@@ -62,8 +63,8 @@ const child = item =>
 
 /** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
 const find = c => {
-    const i3 = cmp.index3(c)
-    const i5 = cmp.index5(c)
+    const i3 = index3(c)
+    const i5 = index5(c)
     /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
     /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
     const f = tail => node => {

package/types/btree/remove/module.f.cjs

@@ -2,8 +2,9 @@ const _ = require('../types/module.f.cjs')
 const cmp = require('../../function/compare/module.f.cjs')
 const find = require('../find/module.f.cjs')
 const list = require('../../list/module.f.cjs')
+const { reduce: listReduce, concat, next } = list
 const array = require('../../array/module.f.cjs')
-const option = require('../../option/module.f.cjs')
+const { map } = require('../../option/module.f.cjs')
 
 /**
  * @template T
@@ -110,7 +111,7 @@ const reduceX = ms => ([i, n]) => a => {
     }
 }
 
-const reduce = list.reduce(reduceX([reduceValue0, reduceValue2]))
+const reduce = listReduce(reduceX([reduceValue0, reduceValue2]))
 
 const initReduce = reduceX([initValue0, initValue1])
 
@@ -123,7 +124,7 @@ const nodeRemove = c => node => {
         /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
         const branch = n => f => {
             const [v, p] = path(/** @type {find.Path<T>} */(undefined))(n)
-            return { first: p.first, tail: list.concat(p.tail)({ first: f(v), tail }) }
+            return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
         switch (i) {
@@ -147,7 +148,7 @@ const nodeRemove = c => node => {
     const r = f()
     if (r === undefined) { return node }
     const { first, tail } = r
-    const tailR = list.next(tail)
+    const tailR = next(tail)
     if (tailR === undefined) { return first }
     const { first: tf, tail: tt } = tailR
     const result = reduce(initReduce(tf)(first))(tt)
@@ -155,7 +156,7 @@ const nodeRemove = c => node => {
 }
 
 /** @type {<T>(c: cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-const remove = c => option.map(nodeRemove(c))
+const remove =  c => map(nodeRemove(c))
 
 module.exports = {
     /** @readonly */

package/types/btree/set/module.f.cjs

@@ -1,7 +1,9 @@
 const _ = require('../types/module.f.cjs')
-const find = require('../find/module.f.cjs')
+const btreeFind = require('../find/module.f.cjs')
+const { find } = btreeFind
 const cmp = require('../../function/compare/module.f.cjs')
 const list = require('../../list/module.f.cjs')
+const { reduce } = list
 
 /**
  * @template T
@@ -11,8 +13,8 @@ const list = require('../../list/module.f.cjs')
 /** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Branch1To3<T>} */
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(i: find.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
-const reduce = ([i, x]) => a => {
+/** @type {<T>(i: btreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
+const reduceOp = ([i, x]) => a => {
     switch (i) {
         case 0: {
             switch (x.length) {
@@ -32,9 +34,11 @@ const reduce = ([i, x]) => a => {
     }
 }
 
+const reduceBranch = reduce(reduceOp)
+
 /** @type {<T>(c: cmp.Compare<T>) => (value: T) => (node: _.Node<T>) => _.Node<T>} */
 const nodeSet = c => value => node => {
-    const { first, tail } = find.find(c)(node)
+    const { first, tail } = find(c)(node)
     const [i, x] = first;
     /** @typedef {typeof value} T */
     /** @type {() => Branch1To3<T>} */
@@ -77,7 +81,7 @@ const nodeSet = c => value => node => {
             }
         }
     }
-    const r = list.reduce(reduce)(f())(tail)
+    const r = reduceBranch(f())(tail)
     return r.length === 1 ? r[0] : r
 }
 

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

@@ -16,11 +16,6 @@ const join = separator => value => prior => `${prior}${separator}${value}`
 /** @type {Fold<string>} */
 const concat = i => acc => `${acc}${i}`
 
-/** @type {Fold<number>} */
-const addition = a => b => a + b
-
-const increment = addition(1)
-
 /**
  * @template T
  * @template R
@@ -38,12 +33,6 @@ const logicalNot = v => !v
 /** @type {<T>(a: T) => (b: T) => boolean} */
 const strictEqual = a => b => a === b
 
-/** @type {Fold<number>} */
-const min = a => b => a < b ? a : b
-
-/** @type {Fold<number>} */
-const max = a => b => a > b ? a : b
-
 /**
  * @template I,O
  * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
@@ -74,6 +63,17 @@ const reduceToScan = reduce => prior => i => {
 /** @type {<T>(fold: Fold<T>) => Scan<T, T>} */
 const foldToScan = op => init => [init, reduceToScan(op)(init)]
 
+/** @type {Fold<number>} */
+const addition = a => b => a + b
+
+/** @type {Fold<number>} */
+const min = a => b => a < b ? a : b
+
+/** @type {Fold<number>} */
+const max = a => b => a > b ? a : b
+
+const increment = addition(1)
+
 const counter = () => increment
 
 module.exports = {

package/types/list/module.f.cjs

@@ -1,6 +1,15 @@
 const { compose, identity } = require('../function/module.f.cjs')
 const operator = require('../function/operator/module.f.cjs')
-const { logicalNot, strictEqual, stateScanToScan, reduceToScan, foldToScan } = operator
+const {
+    join: joinOp,
+    concat: concatOp,
+    counter,
+    logicalNot,
+    strictEqual,
+    stateScanToScan,
+    reduceToScan,
+    foldToScan
+} = operator
 
 /**
  * @template T
@@ -99,10 +108,12 @@ const iterable = list => ({
     }
 })
 
+const { from } = Array
+
 /** @type {<T>(list: List<T>) => readonly T[]} */
 const toArray = list => {
     const u = trampoline(list)
-    return u instanceof Array ? u : Array.from(iterable(u))
+    return u instanceof Array ? u : from(iterable(u))
 }
 
 /** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => Thunk<O>} */
@@ -192,17 +203,23 @@ const last = first => tail => {
 /** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
 const find = def => f => input => first(def)(filter(f)(input))
 
+const findTrue = find(false)
+
 /** @type {(input: List<boolean>) => boolean} */
-const some = input => find
-    (false)
+const some = input => findTrue
     (/** @type {(_: boolean) => boolean} */(identity))
     (input)
 
+/** @type {<T>(f: List<T>) => Thunk<boolean>} */
+const mapTrue = map(() => true)
+
 /** @type {<T>(input: List<T>) => boolean} */
-const isEmpty = input => !some(map(() => true)(input))
+const isEmpty = input => !some(mapTrue(input))
+
+const mapNot = map(logicalNot)
 
 /** @type {(input: List<boolean>) => boolean} */
-const every = input => !some(map(logicalNot)(input))
+const every = input => !some(mapNot(input))
 
 /** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
 const includes = value => input => some(map(strictEqual(value))(input))
@@ -244,17 +261,13 @@ const reduce = op => init => input => last(init)(reduceScan(op)(init)(input))
 /** @type {<T>(op: operator.Fold<T>) => <D>(def: D) => (input: List<T>) => D|T} */
 const fold = op => def => input => last(def)(scan(foldToScan(op))(input))
 
-const sum = fold(operator.addition)(0)
-
-const min = fold(operator.min)(undefined)
-
-const max = fold(operator.max)(undefined)
-
 /** @type {(separator: string) => (input: List<string>) => string} */
-const join = separator => fold(operator.join(separator))('')
+const join = separator => fold(joinOp(separator))('')
+
+const stringConcat = fold(concatOp)('')
 
 /** @type {<T>(input: List<T>) => number} */
-const length = reduce(operator.counter)(0)
+const length = reduce(counter)(0)
 
 /**
  * @template T
@@ -267,7 +280,9 @@ 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 */
-    return stateScan(/** @type {operator.StateScan<T, Number, Entry<T>>} */(entryOperator))(0)(input)
+    /** @type {operator.StateScan<T, Number, Entry<T>>} */
+    const o = entryOperator
+    return stateScan(o)(0)(input)
 }
 
 /** @type {<T>(value: T) => (prior: List<T>) => List<T>} */
@@ -356,14 +371,10 @@ module.exports = {
     /** @readonly */
     fold,
     /** @readonly */
-    sum,
-    /** @readonly */
-    min,
-    /** @readonly */
-    max,
-    /** @readonly */
     join,
     /** @readonly */
+    stringConcat,
+    /** @readonly */
     length,
     /** @readonly */
     entries,

package/types/list/test.f.cjs

@@ -99,11 +99,6 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== '[2,5,9,14]') { throw result }
 }
 
-{
-    const result = _.sum([2, 3, 4, 5])
-    if (result !== 14) { throw result }
-}
-
 {
     const result = _.fold(addition)(undefined)([2, 3, 4, 5])
     if (result !== 14) { throw result }
@@ -211,21 +206,6 @@ const map5 = _.map(x => x > 5)
     if (!result) { throw result }
 }
 
-{
-    const result = _.min([])
-    if (result !== undefined) { throw result }
-}
-
-{
-    const result = _.min([1, 2, 12, -4, 8])
-    if (result !== -4) { throw result }
-}
-
-{
-    const result = _.max([1, 2, 12, -4, 8])
-    if (result !== 12) { throw result }
-}
-
 {
     const result = _.isEmpty(() => [])
     if (result !== true) { throw result }

package/types/map/module.f.cjs

@@ -1,12 +1,13 @@
-const btTypes = require('../btree/types/module.f.cjs')
-const btree = require('../btree/module.f.cjs')
+const btreeTypes = require('../btree/types/module.f.cjs')
 const { values } = require("../btree/module.f.cjs")
-const find = require('../btree/find/module.f.cjs')
-const s = require('../btree/set/module.f.cjs')
+const btreeFind = require('../btree/find/module.f.cjs')
+const { value, find } = btreeFind
+const btreeSet = require('../btree/set/module.f.cjs').set
 const compare = require('../function/compare/module.f.cjs')
 const { stringCmp } = require('../function/compare/module.f.cjs')
 const list = require('../list/module.f.cjs')
-const btRemove = require('../btree/remove/module.f.cjs')
+const { reduce } = list
+const { remove: btreeRemove } = require('../btree/remove/module.f.cjs')
 
 /** @typedef {compare.Sign} Sign */
 
@@ -22,7 +23,7 @@ const btRemove = require('../btree/remove/module.f.cjs')
 
 /**
  * @template T
- * @typedef {btTypes.Tree<Entry<T>>} Map
+ * @typedef {btreeTypes.Tree<Entry<T>>} Map
  */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
@@ -31,12 +32,12 @@ const keyCmp = a => ([b]) => stringCmp(a)(b)
 /** @type {(name: string) => <T>(map: Map<T>) => T|undefined} */
 const at = name => map => {
     if (map === undefined) { return undefined }
-    const result = find.value(find.find(keyCmp(name))(map).first)
+    const result = value(find(keyCmp(name))(map).first)
     return result === undefined ? undefined : result[1]
 }
 
 /** @type {<T>(entry: Entry<T>) => (map: Map<T>) => Map<T>} */
-const setEntry = entry => s.set(keyCmp(entry[0]))(entry)
+const setEntry = entry => btreeSet(keyCmp(entry[0]))(entry)
 
 /** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
 const set = name => value => setEntry([name, value])
@@ -45,10 +46,10 @@ const set = name => value => setEntry([name, value])
 const entries = values
 
 /** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
-const fromEntries = list.reduce(setEntry)(undefined)
+const fromEntries = reduce(setEntry)(undefined)
 
 /** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
-const remove = name => btRemove.remove(keyCmp(name))
+const remove =  name => btreeRemove(keyCmp(name))
 
 module.exports = {
     /** @readonly */

package/types/module.f.cjs

@@ -16,5 +16,5 @@ module.exports = {
     /** @readonly */
     result: require('./result/module.f.cjs'),
     /** @readonly */
-    stringSet: require('./stringset/module.f.cjs'),
+    stringSet: require('./string_set/module.f.cjs'),
 }

package/types/number/module.f.cjs

@@ -0,0 +1,17 @@
+const { fold } = require('../list/module.f.cjs')
+const { addition, min: minOp, max: maxOp } = require('../function/operator/module.f.cjs')
+
+const sum = fold(addition)(0)
+
+const min = fold(minOp)(undefined)
+
+const max = fold(maxOp)(undefined)
+
+module.exports = {
+    /** @readonly */
+    sum,
+    /** @readonly */
+    min,
+    /** @readonly */
+    max,
+}

package/types/number/test.f.cjs

@@ -0,0 +1,23 @@
+const { sum, min, max } = require('./module.f.cjs')
+
+{
+    const result = sum([2, 3, 4, 5])
+    if (result !== 14) { throw result }
+}
+
+{
+    const result = min([])
+    if (result !== undefined) { throw result }
+}
+
+{
+    const result = min([1, 2, 12, -4, 8])
+    if (result !== -4) { throw result }
+}
+
+{
+    const result = max([1, 2, 12, -4, 8])
+    if (result !== 12) { throw result }
+}
+
+module.exports = {}

package/types/object/module.f.cjs

@@ -1,5 +1,8 @@
 const list = require('../list/module.f.cjs')
+const { iterable } = list
 const map = require('../map/module.f.cjs')
+const { entries: mapEntries, fromEntries: mapFromEntries } = map
+const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
 
 /**
  * @template T
@@ -14,16 +17,16 @@ const map = require('../map/module.f.cjs')
  */
 
 /** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
-const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
+const at = name => object => getOwnPropertyDescriptor(object, name)?.value
 
-/** @type {<T>(entries: list.List<Entry<T>>) => list.List<Entry<T>>} */
-const sort = entries => map.entries(map.fromEntries(entries))
+/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
+const sort = e => mapEntries(mapFromEntries(e))
 
-/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
-const fromEntries = entries => Object.fromEntries(list.iterable(entries))
+/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
+const fromEntries = e => objectFromEntries(iterable(e))
 
 /** @type {<T>(m: map.Map<T>) => Map<T>} */
-const fromMap = m => fromEntries(map.entries(m))
+const fromMap =  m => fromEntries(mapEntries(m))
 
 module.exports = {
     /** @readonly */

package/types/object/test.html

@@ -0,0 +1,9 @@
+<html>
+    <body>
+        Hello world!
+        <div id="x"></div>
+        <script>
+            document.getElementById('x').innerText = JSON.stringify({a:0,4294967294:1,4294967295:2})
+        </script>
+    </body>
+</html>

package/types/result/module.cjs

@@ -1,12 +1,13 @@
 const result = require('./module.f.cjs')
+const { ok, error } = result
 
 /** @type {<T>(f: () => T) => result.Result<T, unknown>} */
 const tryCatch = f => {
     // Side effect: `try catch` is not allowed in FunctionalScript.
     try {
-        return result.ok(f())
+        return ok(f())
     } catch (e) {
-        return result.error(e)
+        return error(e)
     }
 }
 

package/types/{stringset → string_set}/module.f.cjs

@@ -1,25 +1,29 @@
 const btTypes = require('../btree/types/module.f.cjs')
 const btree = require('../btree/module.f.cjs')
-const { find } = btree
+const { 
+    find: { find, isFound },
+    remove: { remove: btreeRemove }, 
+    set: { set: btreeSet }, 
+    /** @type {(s: StringSet) => list.List<string>} */
+    values,
+} = btree
 const { stringCmp } = require("../function/compare/module.f.cjs")
 const list = require('../list/module.f.cjs')
+const { reduce } = list
 const { compose } = require('../function/module.f.cjs')
 
 /** @typedef {btTypes.Tree<string>} StringSet */
 
 /** @type {(value: string) => (set: StringSet) => boolean} */
-const contains = value => s => s !== undefined && find.isFound(find.find(stringCmp(value))(s).first)
+const contains = value => s => s !== undefined && isFound(find(stringCmp(value))(s).first)
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
-const set = value => btree.set.set(stringCmp(value))(value)
-
-/** @type {(s: StringSet) => list.List<string>} */
-const values = btree.values
+const set = value => btreeSet(stringCmp(value))(value)
 
-const fromValues = list.reduce(set)(undefined)
+const fromValues = reduce(set)(undefined)
 
 /** @type {(value: string) => (s: StringSet) => StringSet} */
-const remove = compose(stringCmp)(btree.remove.remove)
+const remove = compose(stringCmp)(btreeRemove)
 
 module.exports = {
     /** @readonly */