functionalscript 0.0.444 → 0.0.446

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.444",
+  "version": "0.0.446",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/text/sgr/README.md

@@ -0,0 +1,3 @@
+# SGR (Select Graphic Rendition) parameters
+
+https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_(Select_Graphic_Rendition)_parameters

package/types/range_map/module.f.cjs

@@ -0,0 +1,60 @@
+const sortedList = require("../sorted_list/module.f.cjs")
+const { genericMerge } = sortedList
+const list = require("../list/module.f.cjs")
+const option = require("../option/module.f.cjs")
+const { cmp } = require('../number/module.f.cjs')
+const operator = require("../function/operator/module.f.cjs")
+
+/**
+ * @template T
+ * @typedef {[T, number]} Entry
+ */
+
+/**
+ * @template T
+ * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly union: operator.Reduce<T>
+ *  readonly equal: operator.Equal<T>
+  * }} Operators
+ */
+
+/**
+ * @template T
+ * @typedef {option.Option<Entry<T>>} RangeState
+ */
+
+/**
+ * @template T
+ * @typedef {(a: RangeMap<T>) => (b: RangeMap<T>) => RangeMap<T>} RangeMerge
+ */
+
+/** @type {<T>(union: operator.Reduce<T>) => (equal: operator.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
+  const u = union(aItem)(bItem)
+  const newState = state !== undefined && equal(state[0])(u) ? undefined : state
+  return [newState, sign, [u, min]]
+}
+
+/** @type {<T>(equal: operator.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
+const tailReduce = equal => state => tail => {
+  if (state === undefined) { return tail }
+  const tailResult = list.next(tail)
+  if (tailResult === undefined) { return [state] }
+  if (equal(state[0])(tailResult.first[0])) { return tailResult }
+  return { first: state, tail: tailResult }
+}
+
+ /** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+const merge = ({union, equal}) => genericMerge({reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal)})(undefined)
+
+module.exports = {
+    /** @readonly */
+    merge
+}

package/types/range_map/test.f.cjs

@@ -0,0 +1,81 @@
+const _ = require('./module.f.cjs')
+const { unsafeCmp } = require('../function/compare/module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+const sortedSet = require('../sorted_set/module.f.cjs')
+const { list } = require('../module.f.cjs')
+const operator = require("../function/operator/module.f.cjs")
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+/** @type {_.Operators<sortedSet.SortedSet<string>>} */
+const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) }
+
+module.exports = {
+    merge: [
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = undefined
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = undefined
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['c'], 3]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 2], [['d'], 4]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['d'], 4]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 2], [['c'], 3]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 1], [['a'], 2]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a","b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2], [['a'], 3]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 5]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') { throw result }
+        }
+    ]
+}

package/types/sorted_list/module.f.cjs

@@ -14,11 +14,6 @@ const { identity } = require('../function/module.f.cjs')
  * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
  */
 
-/**
- * @template T
- * @typedef {SortedList<[T, number]>} RangeMap
- */
-
 /**
  * @template T
  * @template S
@@ -51,7 +46,7 @@ const genericMerge = reduce => {
         const aResult = next(a)
         if (aResult === undefined) { return tailReduce(state)(b) }
         const bResult = next(b)
-        if (bResult === undefined) { return tailReduce(state)(a) }
+        if (bResult === undefined) { return tailReduce(state)(aResult) }
         const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
         const aNext = sign === 1 ? a : aResult.tail
         const bNext = sign === -1 ? b : bResult.tail