functionalscript 0.0.437 → 0.0.439

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.437",
+  "version": "0.0.439",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
@@ -29,7 +29,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^18.8.3",
+    "@types/node": "^18.8.4",
     "typescript": "^4.8.4"
   }
 }

package/types/byte_set/module.f.cjs

@@ -10,6 +10,9 @@ const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
 
 const empty = 0n
 
+//                 0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
+const universe = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFFn
+
 /** @type {(n: Byte) => ByteSet} */
 const one = n => 1n << BigInt(n)
 
@@ -28,7 +31,7 @@ const intersect = a => b => a & b
 const difference = a => b => intersect(a)(complement(b))
 
 /** @type {(n: ByteSet) => ByteSet} */
-const complement = n => ~n
+const complement = n => universe ^ n
 
 // additional operations
 
@@ -43,6 +46,8 @@ module.exports = {
     /** @readonly */
     empty,
     /** @readonly */
+    universe,
+    /** @readonly */
     has,
     /** @readonly */
     set,
@@ -54,4 +59,6 @@ module.exports = {
     setRange,
     /** @readonly */
     range,
+    /** @readonly */
+    complement,
 }

package/types/byte_set/test.f.cjs

@@ -1,4 +1,5 @@
 const _ = require('./module.f.cjs')
+const { every, countdown, map } = require('../list/module.f.cjs')
 
 module.exports = {
     has: [
@@ -37,5 +38,19 @@ module.exports = {
             const result = _.unset(255)(a)
             if (result !== 0n) { throw result }
         }
-    ]
+    ],
+    universe: () => {
+        const x = every(map(v => _.has(v)(_.universe))(countdown(256)))
+        if (!x) { throw x }
+    },
+    compliment: {
+        empty: () => {
+            const r = _.complement(_.empty)
+            if (r !== _.universe) { throw r }
+        },
+        universe: () => {
+            const r = _.complement(_.universe)
+            if (r !== _.empty) { throw r }
+        },
+    }
 }

package/types/list/module.f.cjs

@@ -294,16 +294,18 @@ 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>) => List<boolean>} */
-const equalZip = e => a => b => () => {
-    const [aResult, bResult] = [next(a), next(b)]
-    return aResult === undefined || bResult === undefined
-        ? { first: aResult === bResult, tail: undefined }
-        : { first: e(aResult.first)(bResult.first), tail: equalZip(e)(aResult.tail)(bResult.tail) }
-}
-
 /** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-const equal = e => a => b => every(equalZip(e)(a)(b))
+const equal = e => {
+    /** @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)]
+        return aResult === undefined || bResult === undefined
+            ? { first: aResult === bResult, tail: undefined }
+            : { first: e(aResult.first)(bResult.first), tail: f(aResult.tail)(bResult.tail) }
+    }
+    return a => b => every(f(a)(b))
+}
 
 module.exports = {
     /** @readonly */

package/types/nibble_set/module.f.cjs

@@ -1,32 +1,44 @@
-/** @typedef {number} nibbleSet */
-/** @typedef {number} nibble */
+/** @typedef {number} NibbleSet */
+/** @typedef {number} Nibble */
 
 const empty = 0
 
-/** @type {(n: nibble) => (s: nibbleSet) => boolean} */
+const universe = 0xFFFF
+
+/** @type {(n: Nibble) => NibbleSet} */
+const one = n => 1 << n
+
+/** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
 const has = n => s => ((s >> n) & 1) === 1
 
-/** @type {(n: nibble) => (s: nibbleSet) => nibbleSet} */
-const set = n => s => s | (1 << n)
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+const set = n => s => s | one(n)
+
+/** @type {(n: NibbleSet) => NibbleSet} */
+const complement = s => universe ^ s
 
-/** @type {(n: nibble) => (s: nibbleSet) => nibbleSet} */
-const unset = n => s => s & ~(1 << n)
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+const unset = n => s => s & complement(one(n))
 
-/** @type {(r: readonly[number, number]) => (s: nibbleSet) => nibbleSet} */
- const setRange = r => s => s | (((1 << (r[1] - r[0] + 1)) - 1 << r[0]))
+/** @type {(r: readonly[number, number]) => NibbleSet} */
+const range = ([a, b]) => one(b - a + 1) - 1 << a
 
-// how to define FA???
-// const stateA = [init, set] ????
+/** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
+const setRange = r => s => s | range(r)
 
 module.exports = {
     /** @readonly */
     empty,
     /** @readonly */
+    universe,
+    /** @readonly */
     has,
     /** @readonly */
+    complement,
+    /** @readonly */
     set,
     /** @readonly */
     unset,
     /** @readonly */
-    setRange
+    setRange,
 }

package/types/nibble_set/test.f.cjs

@@ -1,3 +1,4 @@
+const { every, map, countdown } = require('../list/module.f.cjs')
 const _ = require('./module.f.cjs')
 
 module.exports = {
@@ -16,7 +17,7 @@ module.exports = {
         },
         () => {
             const s = _.set(15)(_.empty)
-            if (s !== 32768) { throw s }
+            if (s !== 0x8000) { throw s }
             if (_.has(0)(s)) { throw s }
             if (_.has(1)(s)) { throw s }
             if (!_.has(15)(s)) { throw s }
@@ -37,5 +38,19 @@ module.exports = {
     setRange: () => {
         const result = _.setRange([2, 5])(_.empty)
         if (result !== 60) { throw result }
+    },
+    universe: () => {
+        const x = every(map(v => _.has(v)(_.universe))(countdown(16)))
+        if (!x) { throw x }
+    },
+    compliment: {
+        empty: () => {
+            const r = _.complement(_.empty)
+            if (r !== _.universe) { throw r }
+        },
+        universe: () => {
+            const r = _.complement(_.universe)
+            if (r !== _.empty) { throw r }
+        },
     }
 }

package/types/sorted_list/module.f.cjs

@@ -1,7 +1,8 @@
-const compare = require("../function/compare/module.f.cjs")
-const list = require("../list/module.f.cjs")
-const option = require("../option/module.f.cjs")
+const compare = require('../function/compare/module.f.cjs')
+const list = require('../list/module.f.cjs')
+const option = require('../option/module.f.cjs')
 const { next } = list
+const { identity } = require('../function/module.f.cjs')
 
 /**
  * @template T
@@ -13,55 +14,74 @@ const { next } = list
  * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
  */
 
-/** @typedef {number} Byte */
-
 /**
  * @template T
- * @typedef {SortedList<[Byte, readonly string[]]>} RangeMap
+ * @typedef {SortedList<[T, number]>} RangeMap
  */
 
 /**
- * @template S
  * @template T
+ * @template S
  * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Option<T>, compare.Sign, S]} ReduceOp
  */
 
 /**
- * @template S
  * @template T
+ * @template S
  * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
  */
 
 /**
+ * @template T
  * @template S
+  * @typedef {{
+ *  readonly reduceOp: ReduceOp<T,S>
+ *  readonly tailReduce: TailReduce<T,S>
+  * }} MergeReduce
+ */
+
+/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+const genericMerge = reduce => {
+    const { reduceOp, tailReduce } = reduce
+    /** @typedef {typeof reduce extends MergeReduce<infer T, infer S> ? [T, S] : never} TS */
+    /** @typedef {TS[0]} T */
+    /** @typedef {TS[1]} S */
+    /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+    const f = state => a => b => () => {
+        const aResult = next(a)
+        if (aResult === undefined) { return tailReduce(state)(b) }
+        const bResult = next(b)
+        if (bResult === undefined) { return tailReduce(state)(a) }
+        const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
+        const aNext = sign === 1 ? a : aResult.tail
+        const bNext = sign === -1 ? b : bResult.tail
+        const tail = f(stateNext)(aNext)(bNext)
+        return first === undefined ? tail : { first, tail }
+    }
+    return f
+}
+
+/**
  * @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
+ * @typedef {ReduceOp<T, undefined>} CmpReduceOp
  */
 
 /** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-const merge = cmp => genericMerge(undefined)(cmpReduce(cmp))(mergeTail)
+const merge = cmp => {
+    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
+    /** @type {TailReduce<T, undefined>} */
+    const tailReduce = mergeTail
+    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(undefined)
+}
 
-/** @type {<S,T>(cmp: Cmp<T>) => ReduceOp<S, T>} */
-const cmpReduce = cmp => state => a => b => {
+/** @type {<T>(cmp: Cmp<T>) => CmpReduceOp<T>} */
+const cmpReduce = cmp => () => a => b => {
     const sign = cmp(a)(b)
-    return [sign === 1 ? b : a, sign, state]
+    return [sign === 1 ? b : a, sign, undefined]
 }
 
-/** @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 tailReduce(init)(b) }
-    const bResult = next(b)
-    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 }
-}
+/** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
+const mergeTail = () => identity
 
 module.exports = {
     /** @readonly */

package/types/sorted_set/module.f.cjs

@@ -24,16 +24,15 @@ const union = cmp => a => b => toArray(merge(cmp)(a)(b))
 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)
+const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce: intersectTail })(undefined)
 
-/** @type {<S,T>(cmp: Cmp<T>) => sortedList.ReduceOp<S, T>} */
+/** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
 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
+const intersectTail = () => () => undefined
 
 module.exports = {
     /** @readonly */