functionalscript 0.0.436 → 0.0.437

package/package.json

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

package/types/sorted_list/module.f.cjs

@@ -1,6 +1,7 @@
 const compare = require("../function/compare/module.f.cjs")
 const list = require("../list/module.f.cjs")
-const { next, toArray } = list
+const option = require("../option/module.f.cjs")
+const { next } = list
 
 /**
  * @template T
@@ -19,20 +20,52 @@ const { next, toArray } = list
  * @typedef {SortedList<[Byte, readonly string[]]>} RangeMap
  */
 
+/**
+ * @template S
+ * @template T
+ * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Option<T>, compare.Sign, S]} ReduceOp
+ */
+
+/**
+ * @template S
+ * @template T
+ * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
+ */
+
+/**
+ * @template S
+ * @template T
+ * @typedef {(init: S) => (reduce: ReduceOp<S,T>) => (tailReduce: TailReduce<S, T>) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} GenericMerge
+ */
+
 /** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-const merge = cmp => a => b => () => {
+const merge = cmp => genericMerge(undefined)(cmpReduce(cmp))(mergeTail)
+
+/** @type {<S,T>(cmp: Cmp<T>) => ReduceOp<S, T>} */
+const cmpReduce = cmp => state => a => b => {
+    const sign = cmp(a)(b)
+    return [sign === 1 ? b : a, sign, state]
+}
+
+/** @type {<S,T>(state: S) => (tail: list.List<T>) => list.List<T>} */
+const mergeTail = s => input => input
+
+/** @type {<S,T>(init: S) => (reduce: ReduceOp<S,T>) => (tailReduce: TailReduce<S, T>) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+const genericMerge = init => reduce => tailReduce => a => b => () => {
     const aResult = next(a)
-    if (aResult === undefined) { return b }
+    if (aResult === undefined) { return tailReduce(init)(b) }
     const bResult = next(b)
-    if (bResult === undefined) { return a }
-    switch (cmp(aResult.first)(bResult.first)) {
-        case -1: return { first: aResult.first, tail: merge(cmp)(aResult.tail)(b) }
-        case 0: return { first: aResult.first, tail: merge(cmp)(aResult.tail)(bResult.tail) }
-        case 1: return { first: bResult.first, tail: merge(cmp)(a)(bResult.tail) }
-    }
+    if (bResult === undefined) { return tailReduce(init)(a) }
+    const [result, sign, state] = reduce(init)(aResult.first)(bResult.first)
+    const aNext = sign === 1 ? a : aResult.tail
+    const bNext = sign === -1 ? b : bResult.tail
+    const mergeNext = genericMerge(state)(reduce)(tailReduce)(aNext)(bNext)
+    return result === undefined ? mergeNext : { first: result, tail: mergeNext }
 }
 
 module.exports = {
     /** @readonly */
-    merge
+    merge,
+    /** @readonly */
+    genericMerge
 }

package/types/sorted_set/module.f.cjs

@@ -0,0 +1,43 @@
+const compare = require("../function/compare/module.f.cjs")
+const { toArray } = require("../list/module.f.cjs")
+const sortedList = require("../sorted_list/module.f.cjs")
+const { merge, genericMerge } = sortedList
+const list = require("../list/module.f.cjs")
+const option = require("../option/module.f.cjs")
+
+/**
+ * @template T
+ * @typedef {readonly T[]} SortedSet
+ */
+
+/**
+ * @template T
+ * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
+ */
+
+/** @typedef {number} Byte */
+
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
+const union = cmp => a => b => toArray(merge(cmp)(a)(b))
+
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
+const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b))
+
+/** @type {<T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>} */
+const intersectMerge = cmp => genericMerge(undefined)(intersectReduce(cmp))(intersectTail)
+
+/** @type {<S,T>(cmp: Cmp<T>) => sortedList.ReduceOp<S, T>} */
+const intersectReduce = cmp => state => a => b => {
+    const sign = cmp(a)(b)
+    return [sign === 0 ? a : undefined, sign, state]
+}
+
+/** @type {<S,T>(state: S) => (tail: list.List<T>) => list.List<T>} */
+const intersectTail = s => input => undefined
+
+module.exports = {
+    /** @readonly */
+    union,
+    /** @readonly */
+    intersect
+}

package/types/sorted_set/test.f.cjs

@@ -0,0 +1,44 @@
+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 { toArray, countdown, length } = require('../list/module.f.cjs')
+const map = require('../map/module.f.cjs')
+const { flip } = require('../function/module.f.cjs')
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+/** @type {<T>(a: T) => (b: T) => map.Sign} */
+const reverseCmp = flip(unsafeCmp)
+
+module.exports = {
+    union: [
+        () => {
+            const result = stringify(toArray(_.union(unsafeCmp)([2, 3, 4])([1, 3, 5])))
+            if (result !== '[1,2,3,4,5]') { throw result }
+        },
+        () => {
+            const result = stringify(toArray(_.union(unsafeCmp)([1, 2, 3])([])))
+            if (result !== '[1,2,3]') { throw result }
+        },
+        () => {
+            const n = 10_000
+            const sortedSet = toArray(countdown(n))
+            const result = _.union(reverseCmp)(sortedSet)(sortedSet)
+            const len = length(result)
+            if (len != n) { throw result }
+        }
+    ],
+    intersect: [
+        () => {
+            const result = stringify(toArray(_.intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])))
+            console.log(result)
+            if (result !== '[3]') { throw result }
+        },
+        () => {
+            const result = stringify(toArray(_.intersect(unsafeCmp)([1, 2, 3])([])))
+            if (result !== '[]') { throw result }
+        }
+    ]
+}