functionalscript 0.0.283 → 0.0.287

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.283",
+  "version": "0.0.287",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/types/array/index.js

@@ -54,6 +54,18 @@ const seq = require('../list')
 
 /** @typedef {0|1|2|3|4} Index5 */
 
+/**
+ * @template T
+ * @typedef {T extends Array1<infer _> ? Index1 :
+ *  T extends Array2<infer _> ? Index2 :
+ *  T extends Array3<infer _> ? Index3 :
+ *  T extends Array4<infer _> ? Index4 :
+ *  T extends Array5<infer _> ? Index5 :
+ *  T extends readonly (infer _)[] ? number :
+ *  never
+ * } KeyOf
+ */
+
 /** @type {<T>(_: readonly T[]) => readonly T[]} */
 const uncheckTail = a => a.slice(1)
 

package/types/btree/find/index.js

@@ -0,0 +1,104 @@
+const _ = require('..')
+const list = require('../../list')
+const cmp = require('../../function/compare')
+const array = require('../../array')
+
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index3, _.Leaf1<T>]} FirstLeaf1
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[1, _.Branch3<T>]} FirstBranch3
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[1|3, _.Branch5<T>]} FirstBranch5
+ */
+
+/**
+ * @template T
+ * @typedef {FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>} First
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[0|2, _.Branch3<T>]} PathItem3
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[0|2|4, _.Branch5<T>]} PathItem5
+ */
+
+/**
+ * @template T
+ * @typedef {PathItem3<T> | PathItem5<T>} PathItem
+ */
+
+/** @type {<T>(item: PathItem<T>) => _.Node<T>} */
+const child = item => {
+    /** @typedef {typeof item extends PathItem<infer T> ? T : never} T */
+    return /** @type {_.Node<T>} */(item[1][item[0]])
+}
+
+/**
+ * @template T
+ * @typedef {list.List<PathItem<T>>} Path
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+const find = c => {
+    const i3 = cmp.index3(c)
+    const i5 = cmp.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 => {
+        /** @type {(index: array.KeyOf<typeof node>) => Result<T>} */
+        const append = index => {
+            const first = /** @type {PathItem<T>} */([index, node])
+            return f({ first, tail })(child(first))
+        }
+        /** @type {(index: array.KeyOf<typeof node>) => Result<T>} */
+        const done = index => ({ first: /** @type {First<T>} */([index, node]), tail })
+        switch (node.length) {
+            case 1: { return done(i3(node[0])) }
+            case 2: { return done(i5(node)) }
+            case 3: {
+                const i = i3(node[1])
+                switch (i) {
+                    case 0: case 2: { return append(i) }
+                    case 1: { return done(i) }
+                }
+            }
+            case 5: {
+                const i = i5([node[1], node[3]])
+                switch (i) {
+                    case 0: case 2: case 4: { return append(i) }
+                    case 1: case 3: { return done(i) }
+                }
+            }
+        }
+    }
+    return f(undefined)
+}
+
+module.exports = {
+    /** @readonly */
+    find,
+}

package/types/btree/find/test.js

@@ -0,0 +1,119 @@
+const _ = require('.')
+const list = require('../../list')
+const json = require('../../../json')
+const { sort } = require('../../object')
+const btree = require('..')
+const { stringCmp } = require('../../function/compare')
+
+const jsonStr = json.stringify(sort)
+
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => {
+    const result = btree.setVisitor(stringCmp(value))(node)(() => value)
+    switch (result[0]) {
+        case 'replace': case 'overflow': { return result[1] }
+        default: { return node }
+    }
+}
+
+/** @type {(r: _.Result<json.Unknown>) => string} */
+const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))
+
+/** @type {(i: string) => (m: btree.Node<string>) => string} */
+const find = i => m => str(_.find(stringCmp(i))(m))
+
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['1']
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString())
+    {
+        const s = jsonStr(_map)
+        if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') { throw s }
+    }
+    //
+    {
+        const r = find("0")(_map)
+        if (r !== '[0,0,0]') { throw r }
+    }
+    {
+        const r = find("1")(_map)
+        if (r !== '[1,0,0]') { throw r }
+    }
+    {
+        const r = find("10")(_map)
+        if (r !== '[2,0,0]') { throw r }
+    }
+    {
+        const r = find("100")(_map)
+        if (r !== '[3,0,0]') { throw r }
+    }
+    {
+        const r = find("12")(_map)
+        if (r !== '[4,0,0]') { throw r }
+    }
+    {
+        const r = find("16")(_map)
+        if (r !== '[1,0]') { throw r }
+    }
+    {
+        const r = find("17")(_map)
+        if (r !== '[0,2,0]') { throw r }
+    }
+    {
+        const r = find("25")(_map)
+        if (r !== '[1,2,0]') { throw r }
+    }
+    {
+        const r = find("26")(_map)
+        if (r !== '[2,2,0]') { throw r }
+    }
+    {
+        const r = find("36")(_map)
+        if (r !== '[3,2,0]') { throw r }
+    }
+    {
+        const r = find("37")(_map)
+        if (r !== '[4,2,0]') { throw r }
+    }
+    {
+        const r = find("4")(_map)
+        if (r !== '[1]') { throw r }
+    }
+    {
+        const r = find("41")(_map)
+        if (r !== '[0,0,2]') { throw r }
+    }
+    {
+        const r = find("49")(_map)
+        if (r !== '[1,0,2]') { throw r }
+    }
+    {
+        const r = find("5")(_map)
+        if (r !== '[2,0,2]') { throw r }
+    }
+    {
+        const r = find("64")(_map)
+        if (r !== '[1,2]') { throw r }
+    }
+    {
+        const r = find("65")(_map)
+        if (r !== '[0,2,2]') { throw r }
+    }
+    {
+        const r = find("81")(_map)
+        if (r !== '[1,2,2]') { throw r }
+    }
+    {
+        const r = find("85")(_map)
+        if (r !== '[2,2,2]') { throw r }
+    }
+    {
+        const r = find("9")(_map)
+        if (r !== '[3,2,2]') { throw r }
+    }
+    {
+        const r = find("91")(_map)
+        if (r !== '[4,2,2]') { throw r }
+    }
+}

package/types/btree/set/index.js

@@ -0,0 +1,39 @@
+const _ = require('..')
+const { find } = require('../find')
+const cmp = require('../../function/compare')
+const { todo } = require('../../../dev')
+
+/** @type {<T>(c: cmp.Compare<T>) => (value: T) => (node: _.Node<T>) => _.Node<T>} */
+const set = c => value => node => {
+    const { first, tail } = find(c)(node)
+    switch (first[0]) {
+        case 0: {
+            // x2
+            const x = first[1]
+            return todo()
+        }
+        case 1: {
+            // x4
+            const x = first[1];
+            return todo()
+        }
+        case 2: {
+            // x2
+            const x = first[1];
+            return todo()
+        }
+        case 3: {
+            // x2
+            const x = first[1];
+            return todo()
+        }
+        case 4: {
+            // x1
+            const x = first[1];
+            return todo()
+        }
+    }
+    return todo()
+}
+
+module.exports = {}

package/types/btree/test.js

@@ -5,6 +5,8 @@ const { sort } = require('../object')
 const { stringCmp } = require('../function/compare')
 const list = require('../list')
 
+require('./find/test')
+
 const jsonStr = json.stringify(sort)
 
 /** @type {(sequence: list.List<json.Unknown>) => string} */

package/types/list/test.js

@@ -337,6 +337,15 @@ const stress = () => {
         const len = _.length(_.dropWhile(() => true)(result))
         if (len !== 0) { throw len }
     }
+
+    console.log('reverse')
+
+    {
+        // 10_000_000 is too much
+        const n = 5_000_000
+        const result = _.toArray(_.reverse(_.countdown(n)))
+        if (result.length !== n) { throw result.length }
+    }
 }
 
 // stress()