functionalscript 0.0.389 → 0.0.392

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/list/module.f.cjs

@@ -1,6 +1,18 @@
 const { compose, identity } = require('../function/module.f.cjs')
 const operator = require('../function/operator/module.f.cjs')
-const { logicalNot, strictEqual, stateScanToScan, reduceToScan, foldToScan } = operator
+const { 
+    addition, 
+    min: minOp, 
+    max: maxOp, 
+    join: joinOp, 
+    concat: concatOp, 
+    counter,
+    logicalNot, 
+    strictEqual, 
+    stateScanToScan, 
+    reduceToScan, 
+    foldToScan 
+} = operator
 
 /**
  * @template T
@@ -99,10 +111,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 +206,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 +264,19 @@ 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 sum = fold(addition)(0)
 
-const min = fold(operator.min)(undefined)
+const min = fold(minOp)(undefined)
 
-const max = fold(operator.max)(undefined)
+const max = fold(maxOp)(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 +289,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>} */
@@ -364,6 +388,8 @@ module.exports = {
     /** @readonly */
     join,
     /** @readonly */
+    stringConcat,
+    /** @readonly */
     length,
     /** @readonly */
     entries,

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/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 */