functionalscript 0.0.287 → 0.0.288

package/package.json

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

package/types/btree/set/index.js

@@ -1,39 +1,93 @@
 const _ = require('..')
-const { find } = require('../find')
+const find = require('../find')
 const cmp = require('../../function/compare')
-const { todo } = require('../../../dev')
+const list = require('../../list')
 
-/** @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]) {
+/**
+ * @template T
+ * @typedef {_.Branch1<T> | _.Branch3<T>} Result
+ */
+
+/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Result<T>} */
+const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
+
+/** @type {<T>(a: Result<T>) => (i: find.PathItem<T>) => Result<T>} */
+const reduce = a => i => {
+    switch (i[0]) {
         case 0: {
-            // x2
-            const x = first[1]
-            return todo()
-        }
-        case 1: {
-            // x4
-            const x = first[1];
-            return todo()
+            const x = i[1]
+            switch (x.length) {
+                case 3: { return [[...a, x[1], x[2]]] }
+                case 5: { return b57([...a, x[1], x[2], x[3], x[4]]) }
+            }
         }
         case 2: {
-            // x2
-            const x = first[1];
-            return todo()
-        }
-        case 3: {
-            // x2
-            const x = first[1];
-            return todo()
+            const x = i[1]
+            switch (x.length) {
+                case 3: { return [[x[0], x[1], ...a]] }
+                case 5: { return b57([x[0], x[1], ...a, x[3], x[4]]) }
+            }
         }
         case 4: {
-            // x1
-            const x = first[1];
-            return todo()
+            const x = i[1]
+            return b57([x[0], x[1], x[2], x[3], ...a])
+        }
+    }
+}
+
+/** @type {<T>(c: cmp.Compare<T>) => (value: T) => (node: _.Node<T>) => _.Node<T>} */
+const set = c => value => node => {
+    const { first, tail } = find.find(c)(node)
+    /** @typedef {typeof value} T */
+    /** @type {() => Result<T>} */
+    const f = () => {
+        switch (first[0]) {
+            case 0: {
+                // insert
+                const x = first[1]
+                switch (x.length) {
+                    case 1: { return [[value, x[0]]] }
+                    case 2: { return [[value], x[0], [x[1]]] }
+                }
+            }
+            case 1: {
+                // replace
+                const x = first[1];
+                switch (x.length) {
+                    case 1: { return [[value]] }
+                    case 2: { return [[value, x[1]]] }
+                    case 3: { return [[x[0], value, x[2]]] }
+                    case 5: { return [[x[0], value, x[2], x[3], x[4]]] }
+                }
+            }
+            case 2: {
+                // insert
+                const x = first[1];
+                switch (x.length) {
+                    case 1: { return [[x[0], value]] }
+                    case 2: { return [[x[0]], value, [x[1]]] }
+                }
+            }
+            case 3: {
+                // replace
+                const x = first[1];
+                switch (x.length) {
+                    case 2: { return [[x[0], value]] }
+                    case 5: { return [[x[0], x[1], x[2], value, x[4]]]}
+                }
+            }
+            case 4: {
+                // insert
+                const [v0, v1] = first[1];
+                return [[v0], v1, [value]]
+            }
         }
     }
-    return todo()
+    const r = list.reduce(reduce)(f())(tail)
+    return r.length === 1 ? r[0] : r
 }
 
-module.exports = {}
+module.exports = {
+    /** @readonly */
+    set,
+}

package/types/btree/set/test.js

@@ -0,0 +1,19 @@
+const _ = require('.')
+const btree = require('..')
+const { stringCmp } = require('../../function/compare')
+const json = require('../../../json')
+const { sort } = require('../../object')
+
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => _.set(stringCmp(value))(value)(node)
+
+const jsonStr = json.stringify(sort)
+
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['1']
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString())
+    const r = jsonStr(_map)
+    if (r !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') { throw r }
+}

package/types/btree/test.js

@@ -6,6 +6,7 @@ const { stringCmp } = require('../function/compare')
 const list = require('../list')
 
 require('./find/test')
+require('./set/test')
 
 const jsonStr = json.stringify(sort)