functionalscript 0.2.6 → 0.3.1

package/types/btree/find/module.f.ts

@@ -0,0 +1,92 @@
+import * as _ from '../types/module.f.ts'
+import * as List from '../../list/module.f.ts'
+import * as cmp from '../../function/compare/module.f.ts'
+const { index3, index5 } = cmp
+import * as Array from '../../array/module.f.ts'
+
+type FirstLeaf1<T> = readonly[cmp.Index3, _.Leaf1<T>]
+
+type FirstBranch3<T> = readonly[1, _.Branch3<T>]
+
+type FirstLeaf2<T> = readonly[cmp.Index5, _.Leaf2<T>]
+
+type FirstBranch5<T> = readonly[1|3, _.Branch5<T>]
+
+type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>
+
+type PathItem3<T> = readonly[0|2, _.Branch3<T>]
+
+type PathItem5<T> = readonly[0|2|4, _.Branch5<T>]
+
+export type PathItem<T> = PathItem3<T> | PathItem5<T>
+
+const child
+= <T>(item: PathItem<T>): _.TNode<T> => (item[1][item[0]] as _.TNode<T>)
+
+export type Path<T> = List.List<PathItem<T>>
+
+export type Result<T> = {
+    readonly first: First<T>,
+    readonly tail: Path<T>
+}
+
+export const find
+= <T>(c: cmp.Compare<T>): (node: _.TNode<T>) => Result<T> => {
+    const i3 = index3(c)
+    const i5 = index5(c)
+    const f
+        = (tail: Path<T>) => (node: _.TNode<T>): Result<T> => {
+        const append
+            : (index: Array.KeyOf<typeof node>) => Result<T>
+            = index => {
+            const first = [index, node] as PathItem<T>
+            return f({ first, tail })(child(first))
+        }
+        const done
+            : (index: Array.KeyOf<typeof node>) => Result<T>
+            = index => ({ first: [index, node] as First<T>, 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(null)
+}
+
+export const isFound = <T>([i]: First<T>): boolean => {
+    switch (i) {
+        case 1: case 3: { return true }
+        default: { return false }
+    }
+}
+
+export const value = <T>([i, r]: First<T>): T | null => {
+    switch (i) {
+        case 1: {
+            switch (r.length) {
+                case 1: case 2: { return r[0] }
+                default: { return r[1] }
+            }
+        }
+        case 3: {
+            return r.length === 2 ? r[1] : r[3]
+        }
+        default: {
+            return null
+        }
+    }
+}

package/types/btree/find/{test.f.mjs → test.f.ts}

@@ -1,27 +1,31 @@
-import * as _ from './module.f.mjs'
-import * as list from '../../list/module.f.mjs'
-import * as json from '../../../json/module.f.mjs'
-import * as o from '../../object/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as list from '../../list/module.f.ts'
+import * as json from '../../../json/module.f.ts'
+import * as o from '../../object/module.f.ts'
 const { sort } = o
-import * as btree from '../types/module.f.mjs'
-import * as string from '../../string/module.f.mjs'
+import * as btree from '../types/module.f.ts'
+import * as string from '../../string/module.f.ts'
 const { cmp } = string
-import * as s from '../set/module.f.mjs'
+import * as s from '../set/module.f.ts'
 
 const jsonStr = json.stringify(sort)
 
-/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
-const set = node => value => s.set(cmp(value))(() => value)(node)
+const set
+    : (node: btree.TNode<string>) => (value: string) => btree.TNode<string>
+    = node => value => s.set(cmp(value))(() => value)(node)
 
-/** @type {(r: _.Result<json.Unknown>) => string} */
-const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))
+const str
+    : (r: _.Result<json.Unknown>) => string
+    = r => jsonStr(list.toArray(list.map((x: any) => x[0])(r)))
 
-/** @type {(i: string) => (m: btree.Node<string>) => string} */
-const find = i => m => str(_.find(cmp(i))(m))
+const find
+    : (i: string) => (m: btree.TNode<string>) => string
+    = i => m => str(_.find(cmp(i))(m))
 
 const test = () => {
-    /** @type {btree.Node<string>} */
-    let _map = ['1']
+    let _map
+        : btree.TNode<string>
+        = ['1']
     for (let i = 2; i <= 10; i++)
         _map = set(_map)((i * i).toString())
     {
@@ -115,4 +119,4 @@ const test = () => {
     }
 }
 
-export default test
+export default test

package/types/btree/{module.f.mjs → module.f.ts}

@@ -1,13 +1,12 @@
-// @ts-self-types="./module.f.d.mts"
-
-import * as list from '../list/module.f.mjs'
+import * as list from '../list/module.f.ts'
 const { flat } = list
-import * as n from '../nullable/module.f.mjs'
+import * as n from '../nullable/module.f.ts'
 const { map } = n
-import * as _ from './types/module.f.mjs'
+import * as _ from './types/module.f.ts'
 
-/** @type {<T>(node: _.Node<T>) => list.Thunk<T>} */
-const nodeValues = node => () => {
+const nodeValues
+    : <T>(node: _.TNode<T>) => list.Thunk<T>
+    = node => () => {
     switch (node.length) {
         case 1: case 2: { return node }
         case 3: {
@@ -31,5 +30,6 @@ const nodeValues = node => () => {
 
 export const empty = null
 
-/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
-export const values = map(nodeValues)
+export const values
+    : <T>(tree: _.Tree<T>) => list.List<T>
+    = map(nodeValues)

package/types/btree/remove/{module.f.mjs → module.f.ts}

@@ -1,28 +1,22 @@
-// @ts-self-types="./module.f.d.mts"
-import * as _ from '../types/module.f.mjs'
-import * as Cmp from '../../function/compare/module.f.mjs'
-import * as find from '../find/module.f.mjs'
-import * as list from '../../list/module.f.mjs'
+import * as _ from '../types/module.f.ts'
+import * as Cmp from '../../function/compare/module.f.ts'
+import * as find from '../find/module.f.ts'
+import * as list from '../../list/module.f.ts'
 const { fold, concat, next } = list
-import * as Array from '../../array/module.f.mjs'
-import * as n from '../../nullable/module.f.mjs'
+import * as Array from '../../array/module.f.ts'
+import * as n from '../../nullable/module.f.ts'
 const { map } = n
 
-/**
- * @template T
- * @typedef {null | _.Leaf1<T>} Leaf01
- */
+type Leaf01<T> = null | _.Leaf1<T>
 
-/**
- * @template T
- * @typedef {{
- *  readonly first: Leaf01<T>,
- *  readonly tail: find.Path<T>
- * }} RemovePath
- */
+type RemovePath<T> = {
+   readonly first: Leaf01<T>,
+   readonly tail: find.Path<T>
+}
 
-/** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
-const path = tail => n => {
+const path
+    : <T>(tail: find.Path<T>) => (n: _.TNode<T>) => readonly[T, RemovePath<T>]
+    = tail => n => {
     switch (n.length) {
         case 1: { return [n[0], { first: null, tail }] }
         case 2: { return [n[0], { first: [n[1]], tail }] }
@@ -31,13 +25,11 @@ const path = tail => n => {
     }
 }
 
-/**
- * @template T
- * @typedef {_.Branch1<T> | _.Branch3<T> | _.Branch5<T>} Branch
- */
+type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>
 
-/** @type {<T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
-const reduceValue0 = a => n => {
+const reduceValue0
+    : <T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
+    = a => n => {
     const [, v1, n2] = n
     if (a.length === 1) {
         switch (n2.length) {
@@ -50,8 +42,9 @@ const reduceValue0 = a => n => {
     }
 }
 
-/** @type {<T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
-const reduceValue2 = a => n => {
+const reduceValue2
+    : <T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
+    = a => n => {
     const [n0, v1, ] = n
     if (a.length === 1) {
         switch (n0.length) {
@@ -64,8 +57,9 @@ const reduceValue2 = a => n => {
     }
 }
 
-/** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
-const initValue0 = a => n => {
+const initValue0
+    : <T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
+    = a => n => {
     const [, v1, n2] = n
     if (a === null) {
         switch (n2.length) {
@@ -78,8 +72,9 @@ const initValue0 = a => n => {
     }
 }
 
-/** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
-const initValue1 = a => n => {
+const initValue1
+    : <T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
+    = a => n => {
     const [n0, v1] = n
     if (a === null) {
         switch (n0.length) {
@@ -90,19 +85,14 @@ const initValue1 = a => n => {
     } else { return [n0, v1, a] }
 }
 
-/**
- * @template A,T
- * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
- */
+type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
 
-/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: find.PathItem<T>) => (a: A) => Branch<T>} */
-const reduceX = ms => ([i, n]) => a => {
+const reduceX
+    = <A, T>(ms: Array.Array2<Merge<A, T>>) => ([i, n]: find.PathItem<T>) => (a: A): Branch<T> => {
     const [m0, m2] = ms
-    /** @typedef {typeof ms extends Array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
-    /** @typedef {AT[0]} A */
-    /** @typedef {AT[1]} T */
-    /** @type {(m: Merge<A, T>) => Branch<T>} */
-    const f = m => {
+    const f
+        : (m: Merge<A, T>) => Branch<T>
+        = m => {
         const ra = m(a)
         return n.length === 3 ? ra(n) : [...ra([n[0], n[1], n[2]]), n[3], n[4]]
     }
@@ -117,15 +107,14 @@ const reduce = fold(reduceX([reduceValue0, reduceValue2]))
 
 const initReduce = reduceX([initValue0, initValue1])
 
-/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-export const nodeRemove = c => node => {
-    /** @typedef {typeof c extends Cmp.Compare<infer T> ? T : never} T */
-    /** @type  {() => null | RemovePath<T>} */
-    const f = () => {
+export const nodeRemove
+    = <T>(c: Cmp.Compare<T>) => (node: _.TNode<T>): _.Tree<T> => {
+    const f = (): null | RemovePath<T> => {
         const { first, tail } = find.find(c)(node)
-        /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
-        const branch = n => f => {
-            const [v, p] = path(/** @type {find.Path<T>} */(null))(n)
+        const branch
+            : (n: _.TNode<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>
+            = n => f => {
+            const [v, p] = path(null as find.Path<T>)(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
@@ -157,5 +146,6 @@ export const nodeRemove = c => node => {
     return result.length === 1 ? result[0] : result
 }
 
-/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-export const remove =  c => map(nodeRemove(c))
+export const remove
+    : <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>
+    = c => map(nodeRemove(c))

package/types/btree/remove/{test.f.mjs → test.f.ts}

@@ -1,23 +1,26 @@
-import * as _ from './module.f.mjs'
-import * as BTree from '../types/module.f.mjs'
-import * as s from '../set/module.f.mjs'
-import * as str from '../../string/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as BTree from '../types/module.f.ts'
+import * as s from '../set/module.f.ts'
+import * as str from '../../string/module.f.ts'
 const { cmp } = str
-import * as json from '../../../json/module.f.mjs'
-import * as o from '../../object/module.f.mjs'
+import * as json from '../../../json/module.f.ts'
+import * as o from '../../object/module.f.ts'
 const { sort } = o
 
-/** @type {(node: BTree.Node<string>) => (value: string) => BTree.Node<string>} */
-const set = node => value => s.set(cmp(value))(() => value)(node)
+const set
+    : (node: BTree.TNode<string>) => (value: string) => BTree.TNode<string>
+    = node => value => s.set(cmp(value))(() => value)(node)
 
-/** @type {(node: BTree.Node<string>) => (value: string) => BTree.Node<string> | null} */
-const remove = node => value => _.nodeRemove(cmp(value))(node)
+const remove
+    : (node: BTree.TNode<string>) => (value: string) => BTree.TNode<string> | null
+    = node => value => _.nodeRemove(cmp(value))(node)
 
 const jsonStr = json.stringify(sort)
 
 const test = () => {
-    /** @type {BTree.Node<string> | null} */
-    let _map = ['1']
+    let _map
+        : BTree.TNode<string> | null
+        = ['1']
     for (let i = 2; i <= 38; i++)
         _map = set(_map)((i * i).toString())
     {
@@ -411,8 +414,9 @@ const test = () => {
 }
 
 const test2 = () => {
-    /** @type {BTree.Node<string>|null} */
-    let _map = ['1']
+    let _map
+        : BTree.TNode<string>|null
+        = ['1']
     for (let i = 2; i <= 10; i++)
         _map = set(_map)((i * i).toString())
     if (_map.length !== 3) { throw _map }
@@ -491,4 +495,4 @@ const test2 = () => {
 export default {
     test,
     test2,
-}
+}

package/types/btree/set/{module.f.mjs → module.f.ts}

@@ -1,21 +1,19 @@
-// @ts-self-types="./module.f.d.mts"
-import * as _ from '../types/module.f.mjs'
-import * as btreeFind from '../find/module.f.mjs'
+import * as _ from '../types/module.f.ts'
+import * as btreeFind from '../find/module.f.ts'
 const { find } = btreeFind
-import * as Cmp from '../../function/compare/module.f.mjs'
-import * as list from '../../list/module.f.mjs'
+import * as Cmp from '../../function/compare/module.f.ts'
+import * as list from '../../list/module.f.ts'
 const { fold } = list
 
-/**
- * @template T
- * @typedef {_.Branch1<T> | _.Branch3<T>} Branch1To3
- */
+type Branch1To3<T> = _.Branch1<T> | _.Branch3<T>
 
-/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Branch1To3<T>} */
-const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
+const b57
+    : <T>(b: _.Branch5<T> | _.Branch7<T>) => Branch1To3<T>
+    = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(i: btreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
-const reduceOp = ([i, x]) => a => {
+const reduceOp
+    : <T>(i: btreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>
+    = ([i, x]) => a => {
     switch (i) {
         case 0: {
             switch (x.length) {
@@ -37,13 +35,11 @@ const reduceOp = ([i, x]) => a => {
 
 const reduceBranch = fold(reduceOp)
 
-/** @type {<T>(c: Cmp.Compare<T>) => (g: (value: T | null) => T) => (node: _.Node<T>) => _.Node<T>} */
-const nodeSet = c => g => node => {
+const nodeSet
+    = <T>(c: Cmp.Compare<T>) => (g: (value: T | null) => T) => (node: _.TNode<T>): _.TNode<T> => {
     const { first, tail } = find(c)(node)
     const [i, x] = first;
-    /** @typedef {typeof c extends Cmp.Compare<infer T> ? T : never} T */
-    /** @type {() => Branch1To3<T>} */
-    const f = () => {
+    const f = (): Branch1To3<T> => {
         switch (i) {
             case 0: {
                 // insert
@@ -88,5 +84,6 @@ const nodeSet = c => g => node => {
     return r.length === 1 ? r[0] : r
 }
 
-/** @type {<T>(c: Cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
-export const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree)
+export const set
+    : <T>(c: Cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.TNode<T>
+    = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree)