functionalscript 0.0.294 → 0.0.295

package/package.json

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

package/types/btree/find/index.js

@@ -98,7 +98,29 @@ const find = c => {
     return f(undefined)
 }
 
+/** @type {<T>(first: First<T>) => T | undefined} */
+const value = first => {
+    switch (first[0]) {
+        case 1: {
+            const x = first[1]
+            switch (x.length) {
+                case 1: case 2: { return x[0] }
+                default: { return x[1] }
+            }
+        }
+        case 3: {
+            const x = first[1]
+            return x.length === 2 ? x[1] : x[3]
+        }
+        default: {
+            return undefined
+        }
+    }
+}
+
 module.exports = {
     /** @readonly */
     find,
+    /** @readonly */
+    value,
 }

package/types/btree/find/test.js

@@ -4,17 +4,12 @@ const json = require('../../../json')
 const { sort } = require('../../object')
 const btree = require('..')
 const { stringCmp } = require('../../function/compare')
+const s = require('../set')
 
 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 }
-    }
-}
+const set = node => value => s.set(stringCmp(value))(value)(node)
 
 /** @type {(r: _.Result<json.Unknown>) => string} */
 const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))

package/types/btree/index.js

@@ -1,18 +1,5 @@
-const { todo } = require('../../dev')
-const cmp = require('../function/compare')
-const { index3, index5 } = cmp
 const seq = require('../list')
 
-/**
- * @template T
- * @typedef {() => T} Lazy
- */
-
-/**
- * @template T
- * @typedef {cmp.Compare<T>} Cmp
- */
-
 /**
  * @template T
  * @typedef {readonly[T]} Array1
@@ -61,268 +48,11 @@ const seq = require('../list')
  * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
-/** @typedef {readonly['done']} NotFoundDone */
-
-/**
- * @template T
- * @typedef {readonly['done', T]} FoundDone
- */
-
-/**
- * @template T
- * @typedef { NotFoundDone | FoundDone<T> } Done
- */
-
-/**
- * @template T
- * @typedef {readonly['replace', Node<T>]} Replace
- */
-
-/**
- * @template T
- * @typedef {readonly['overflow', Branch3<T>]} Overflow
- */
-
-/**
- * @template T
- * @typedef { Done<T> | Replace<T> | Overflow<T> } Result
- */
-
-/** @typedef {<T>(_: Leaf1<T>) => LazyResult<T>} InLeaf1 */
-/** @typedef {<T>(_: Leaf2<T>) => LazyResult<T>} InLeaf2 */
-/** @typedef {<T>(_: Branch3<T>) => LazyResult<T>} InBranch3 */
-/** @typedef {<T>(_: Branch5<T>) => LazyResult<T>} InBranch5 */
-
-/**
- * @typedef {{
- *  readonly leaf1: InLeaf1
- *  readonly leaf2_left: InLeaf2
- *  readonly leaf2_right: InLeaf2
- *  readonly branch3: InBranch3
- *  readonly branch5_left: InBranch5
- *  readonly branch5_right: InBranch5
- * }} Found
- */
-
-/**
- * @typedef {{
- *  readonly leaf1_left: InLeaf1
- *  readonly leaf1_right: InLeaf1
- *  readonly leaf2_left: InLeaf2
- *  readonly leaf2_middle: InLeaf2
- *  readonly leaf2_right: InLeaf2
- * }} NotFound
- */
-
-/**
- * @template T
- * @typedef {(f: (_: Node<T>) => LazyResult<T>) => LazyResult<T>} FResult<T>
- */
-
-/**
- * @typedef {{
- *  readonly branch3_left: <T>(branch3: Branch3<T>) => FResult<T>
- *  readonly branch3_right: <T>(branch3: Branch3<T>) => FResult<T>
- *  readonly branch5_left: <T>(branch5: Branch5<T>) => FResult<T>
- *  readonly branch5_middle: <T>(branch5: Branch5<T>) => FResult<T>
- *  readonly branch5_right: <T>(branch5: Branch5<T>) => FResult<T>
- * }} Continue
- */
-
-/**
- * @typedef {{
- *  readonly found: Found
- *  readonly notFound: NotFound
- * }} Visitor
- */
-
 /**
  * @template T
  * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
  */
 
-/** @type {<T>(n: Branch7<T>) => Branch3<T>} */
-const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
-
-/**
- * @template T
- * @typedef {(init: Lazy<T>) => Result<T>} LazyResult
- */
-
-/**
- * @type {<T>(extend: (o: Branch3<T>) => Result<T>) =>
- *  (replace: (r: Node<T>) => Node<T>) =>
- *  (result: LazyResult<T>) =>
- *  LazyResult<T>}
- */
-const merge = extend => replace => lazyResult => init => {
-    const result = lazyResult(init)
-    switch (result[0]) {
-        case 'done': { return result }
-        case 'replace': { return ['replace', replace(result[1])] }
-        default: { return extend(result[1]) }
-    }
-}
-
-/** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (node: Node<T>) => LazyResult<T>} */
-const visit = ({ found, notFound }) => cmp => {
-    const i3 = index3(cmp)
-    const i5 = index5(cmp)
-    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T */
-    /**
-     * @type {(extend: (o: Branch3<T>) => Branch5<T>) =>
-     *  (replace: (r: Node<T>) => Branch3<T>) =>
-     *  (result: LazyResult<T>) =>
-     *  LazyResult<T>}
-     */
-    const merge2 = extend => merge(o => ['replace', extend(o)])
-    /**
-     * @type {(extend: (o: Branch3<T>) => Branch7<T>) =>
-     *  (replace: (r: Node<T>) => Branch5<T>) =>
-     *  (result: LazyResult<T>) =>
-     *  LazyResult<T>}
-     */
-    const merge3 = extend => merge(o => ['overflow', split(extend(o))])
-    /** @type {(node: Node<T>) => LazyResult<T>} */
-    const f = node => {
-        switch (node.length) {
-            case 1: {
-                switch (i3(node[0])) {
-                    case 0: { return notFound.leaf1_left(node) }
-                    case 1: { return found.leaf1(node) }
-                    default: { return notFound.leaf1_right(node) }
-                }
-            }
-            case 2: {
-                switch (i5(node)) {
-                    case 0: { return notFound.leaf2_left(node) }
-                    case 1: { return found.leaf2_left(node) }
-                    case 2: { return notFound.leaf2_middle(node) }
-                    case 3: { return found.leaf2_right(node) }
-                    default: { return notFound.leaf2_right(node) }
-                }
-            }
-            case 3: {
-                const [n0, v1, n2] = node
-                switch (i3(v1)) {
-                    case 0: {
-                        return merge2
-                            (e => [...e, v1, n2])
-                            (r => [r, v1, n2])
-                            (f(n0))
-                    }
-                    case 1: { return found.branch3(node) }
-                    default: {
-                        return merge2
-                            (e => [n0, v1, ...e])
-                            (r => [n0, v1, r])
-                            (f(n2))
-                    }
-                }
-            }
-            default: {
-                const [n0, v1, n2, v3, n4] = node
-                switch (i5([v1, v3])) {
-                    case 0: {
-                        return merge3
-                            (o => [...o, v1, n2, v3, n4])
-                            (r => [r, v1, n2, v3, n4])
-                            (f(n0))
-                    }
-                    case 1: { return found.branch5_left(node) }
-                    case 2: {
-                        return merge3
-                            (o => [n0, v1, ...o, v3, n4])
-                            (r => [n0, v1, r, v3, n4])
-                            (f(n2))
-                    }
-                    case 3: { return found.branch5_right(node) }
-                    default: {
-                        return merge3
-                            (o => [n0, v1, n2, v3, ...o])
-                            (r => [n0, v1, n2, v3, r])
-                            (f(n4))
-                    }
-                }
-            }
-        }
-    }
-    return f
-}
-
-/** @type { <T>(_: T) => Done<T> } */
-const found = value => ['done', value]
-
-/** @type {Found} */
-const foundGet = {
-    leaf1: ([value]) => () => found(value),
-    leaf2_left: ([value]) => () => found(value),
-    leaf2_right: ([, value]) => () => found(value),
-    branch3: ([, value]) => () => found(value),
-    branch5_left: ([, value]) => () => found(value),
-    branch5_right: ([, , , value]) => () => found(value),
-}
-/** @type { () => () => NotFoundDone } */
-const notFound = () => () => ['done']
-
-/** @type {NotFound} */
-const notFoundGet = {
-    leaf1_left: notFound,
-    leaf1_right: notFound,
-    leaf2_left: notFound,
-    leaf2_middle: notFound,
-    leaf2_right: notFound,
-}
-
-/** @type { <T>(_: Node<T>) => Replace<T> } */
-const replace = node => ['replace', node]
-
-/** @type {Found} */
-const foundReplace = {
-    leaf1: () => f => replace([f()]),
-    leaf2_left: ([, v1]) => f => replace([f(), v1]),
-    leaf2_right: ([v0,]) => f => replace([v0, f()]),
-    branch3: ([n0, , n2]) => f => replace([n0, f(), n2]),
-    branch5_left: ([n0, , n2, v3, n4]) => f => replace([n0, f(), n2, v3, n4]),
-    branch5_right: ([n0, v1, n2, , n4]) => f => replace([n0, v1, n2, f(), n4])
-}
-
-/** @type {<T>(leaf3: Array3<T>) => Result<T>} */
-const overflow = ([v0, v1, v2]) => ['overflow', [[v0], v1, [v2]]]
-
-/** @type {NotFound} */
-const notFoundInsert = {
-    leaf1_left: ([v]) => f => replace([f(), v]),
-    leaf1_right: ([v]) => f => replace([v, f()]),
-    leaf2_left: ([v0, v1]) => f => overflow([f(), v0, v1]),
-    leaf2_middle: ([v0, v1]) => f => overflow([v0, f(), v1]),
-    leaf2_right: ([v0, v1]) => f => overflow([v0, v1, f()]),
-}
-
-/** @type {Visitor} */
-const getVisitor = {
-    found: foundGet,
-    notFound: notFoundGet,
-}
-
-/** @type {Visitor} */
-const setVisitor = {
-    found: foundReplace,
-    notFound: notFoundInsert,
-}
-
-/** @type {Visitor} */
-const getOrInsertVisitor = {
-    found: foundGet,
-    notFound: notFoundInsert,
-}
-
-/** @type {Visitor} */
-const replaceVisitor = {
-    found: foundReplace,
-    notFound: notFoundGet,
-}
-
 /** @type {<T>(node: Node<T>) => seq.Thunk<T>} */
 const values = node => () => {
     switch (node.length) {
@@ -351,109 +81,7 @@ const values = node => () => {
  * @typedef {readonly[Node<T>]} Branch1
  */
 
-/**
- * @template T
- * @typedef { Branch1<T> | Branch3<T> } ConcatResult
- */
-
-/**
- * @template T
- * @typedef {readonly[...Branch7<T>,T,Node<T>]} Branch9
- */
-
-/**
- * @template T
- * @typedef {readonly[...Branch9<T>,T,Node<T>]} Branch11
- */
-
-/** @type {<T>(n: Branch5<T> | Branch7<T> | Branch9<T> | Branch11<T>) => Branch1<T> | Branch3<T>} */
-const up = n => {
-    switch (n.length) {
-        case 5: { return [n] }
-        case 7: {
-            const [n0, v1, n2, v3, n4, v5, n6] = n
-            return [[n0, v1, n2], v3, [n4, v5, n6]]
-        }
-        case 9: {
-            const [n0, v1, n2, v3, n4, v5, n6, v7, n8] = n
-            return [[n0, v1, n2], v3, [n4, v5, n6, v7, n8]]
-        }
-        case 11: {
-            const [n0, v1, n2, v3, n4, v5, n6, v7, n8, v9, n10] = n
-            return [[n0, v1, n2, v3, n4], v5, [n6, v7, n8, v9, n10]]
-        }
-    }
-}
-
-/**
- * @template T
- * @typedef {readonly[Node<T>,T]} Head2
- */
-
-/**
- * @template T
- * @typedef {readonly[...Head2<T>, ...Head2<T>]} Head4
- */
-
-/**
- * @template T
- * @typedef {Head2<T>|Head4<T>} Head
- */
-
-/** @type {<T>(n: Branch3<T> | Branch5<T>) => readonly[Head<T>, Node<T>]} */
-const headLast = n => {
-    if (n.length === 3) {
-        const [n0, v1, n2] = n
-        return [[n0, v1], n2]
-    } else {
-        const [n0, v1, n2, v3, n4] = n
-        return [[n0, v1, n2, v3], n4]
-    }
-}
-
-/** @type {<T>(a: Node<T>) => (b: Node<T>) => ConcatResult<T>} */
-const concat = a => b => {
-    /** @typedef {typeof a extends Node<infer T> ? T : never} T */
-    switch (a.length) {
-        case 1: {
-            switch (b.length) {
-                case 1: { return [[a[0], b[0]]] }
-                case 2: { return [a, b[0], [b[1]]] }
-                default: { throw 'invalid b node' }
-            }
-        }
-        case 2: { return [[a[0]], a[1], b] }
-        default: {
-            switch (b.length) {
-                case 3: case 5: {
-                    const [aHead, aLast] = headLast(a)
-                    const [bFirst, ...bTail] = b
-                    return up([...aHead, ...concat(aLast)(bFirst), ...bTail])
-                }
-                default: { throw 'invalid b node' }
-            }
-        }
-    }
-}
-
 module.exports = {
     /** @readonly */
     values,
-    /**
-     * @readonly
-     * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
-     */
-    getVisitor: cmp => node => {
-        const result = visit(getVisitor)(cmp)(node)(() => { throw 'getVisitor' })
-        if (result[0] !== 'done') { throw 'getVisitor result' }
-        return result[1]
-    },
-    /** @readonly */
-    setVisitor: visit(setVisitor),
-    /** @readonly */
-    getOrInsertVisitor: visit(getOrInsertVisitor),
-    /** @readonly */
-    replaceVisitor: visit(replaceVisitor),
-    /** @readonly */
-    concat,
 }

package/types/btree/remove/test.js

@@ -407,3 +407,81 @@ const jsonStr = json.stringify(sort)
         if (_map !== undefined) { throw _map }
     }
 }
+
+{
+    /** @type {btree.Node<string>|undefined} */
+    let _map = ['1']
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString())
+    if (_map.length !== 3) { throw _map }
+    let _s = jsonStr(_map)
+    if (_s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') { throw _s }
+
+    {
+        _map = remove(_map)("4")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[[["1","100"],"16",["25","36"]],"49",[["64"],"81",["9"]]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("49")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25","36"],"64",["81","9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("64")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25","36"],"81",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("81")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25"],"36",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("36")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25","9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("16")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"25",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("25")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1"],"100",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("100")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '["1","9"]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("9")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '["1"]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("1")
+        if (_map !== undefined) { throw _map }
+    }
+}

package/types/btree/set/index.js

@@ -5,13 +5,13 @@ const list = require('../../list')
 
 /**
  * @template T
- * @typedef {_.Branch1<T> | _.Branch3<T>} Result
+ * @typedef {_.Branch1<T> | _.Branch3<T>} Bracnh1To3
  */
 
-/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Result<T>} */
+/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Bracnh1To3<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>} */
+/** @type {<T>(a: Bracnh1To3<T>) => (i: find.PathItem<T>) => Bracnh1To3<T>} */
 const reduce = a => i => {
     switch (i[0]) {
         case 0: {
@@ -39,7 +39,7 @@ const reduce = a => i => {
 const set = c => value => node => {
     const { first, tail } = find.find(c)(node)
     /** @typedef {typeof value} T */
-    /** @type {() => Result<T>} */
+    /** @type {() => Bracnh1To3<T>} */
     const f = () => {
         switch (first[0]) {
             case 0: {

package/types/btree/test.js

@@ -1,9 +1,11 @@
 const btree = require('.')
-const { getVisitor, setVisitor, values, concat } = btree
+const { values } = btree
 const json = require('../../json')
 const { sort } = require('../object')
 const { stringCmp } = require('../function/compare')
 const list = require('../list')
+const s = require('./set')
+const f = require('./find')
 
 require('./find/test')
 require('./set/test')
@@ -15,13 +17,7 @@ const jsonStr = json.stringify(sort)
 const stringify = sequence => jsonStr(list.toArray(sequence))
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
-const set = node => value => {
-    const result = setVisitor(stringCmp(value))(node)(() => value)
-    switch (result[0]) {
-        case 'replace': case 'overflow': { return result[1] }
-        default: { return node }
-    }
-}
+const set = node => value => s.set(stringCmp(value))(value)(node)
 
 {
     /** @type {btree.Node<string>} */
@@ -49,8 +45,8 @@ const set = node => value => {
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
-    const result = getVisitor(stringCmp('b'))(_map)
-    if (result === undefined) { throw result }
+    const result = f.value(f.find(stringCmp('b'))(_map).first)
+    if (result !== 'b') { throw result }
 }
 
 {
@@ -58,52 +54,10 @@ const set = node => value => {
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
-    const result = getVisitor(stringCmp('e'))(_map)
+    const result = f.value(f.find(stringCmp('e'))(_map).first)
     if (result !== undefined) { throw result }
 }
 
-{
-    /** @type {btree.Node<string>} */
-    let _map = ['1']
-    for (let i = 2; i <= 10; i++)
-        _map = set(_map)((i * i).toString())
-    if (_map.length !== 3) { throw _map }
-    let _s = jsonStr(_map)
-    if (_s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') { throw _s }
-
-    let [a,,b] = _map
-    let _c = concat(a)(b)
-    if (_c.length !== 3) { throw _c }
-    _s =jsonStr(_c);
-    if (_s !== '[[["1","100"],"16",["25"]],"36",[["49"],"64",["81","9"]]]') { throw _s }
-
-    [a,,b] = _c
-    _c = concat(a)(b)
-    if (_c.length !== 1) { throw _c }
-    _s = jsonStr(_c);
-    if (_s !== '[[["1","100"],"16",["25","49"],"64",["81","9"]]]') { throw _s }
-
-    let [_r] = _c
-    if (_r.length !== 5) { throw _r }
-    [a,,b] = _r
-    _c = concat(a)(b)
-    if (_c.length !== 3) { throw _c }
-    _s = jsonStr(_c);
-    if (_s !== '[["1"],"100",["25","49"]]') { throw _s }
-
-    [a,,b] = _c
-    _c = concat(a)(b)
-    if (_c.length !== 3) { throw _c }
-    _s = jsonStr(_c);
-    if (_s !== '[["1"],"25",["49"]]') { throw _s }
-
-    [a,,b] = _c
-    _c = concat(a)(b)
-    if (_c.length !== 1) { throw _c }
-    _s = jsonStr(_c);
-    if (_s !== '[["1","49"]]') { throw _s }
-}
-
 const test = () => {
     /** @type {btree.Node<string>} */
     let _map = ['a']

package/types/map/index.js

@@ -1,6 +1,8 @@
 const option = require("../option")
 const btree = require('../btree')
-const { getVisitor, setVisitor, values } = require("../btree")
+const { values } = require("../btree")
+const find = require('../btree/find')
+const s = require('../btree/set')
 const compare = require("../function/compare")
 const { stringCmp } = require("../function/compare")
 const list = require("../list")
@@ -38,7 +40,7 @@ const keyCmp = a => ([b]) => stringCmp(a)(b)
 /** @type {(name: string) => <T>(map: Map<T>) => T|undefined} */
 const at = name => map => {
     if (map === undefined) { return undefined }
-    const result = getVisitor(keyCmp(name))(map)
+    const result = find.value(find.find(keyCmp(name))(map).first)
     return result === undefined ? undefined : result[1]
 }
 
@@ -47,11 +49,7 @@ const set = name => value => map =>  {
     /** @type {Entry<typeof value>} */
     const entry = [name, value]
     if (map === undefined) { return [entry] }
-    const result = setVisitor(keyCmp(name))(map)(() => entry)
-    switch (result[0]) {
-        case 'replace': case 'overflow': { return result[1] }
-        default: { throw 'invalid BTree operation' }
-    }
+    return s.set(keyCmp(name))(entry)(map)
 }
 
 /** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */