functionalscript 0.2.5 → 0.3.0

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

@@ -1,125 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as _ from '../types/module.f.mjs'
-import * as List from '../../list/module.f.mjs'
-import * as cmp from '../../function/compare/module.f.mjs'
-const { index3, index5 } = cmp
-import * as Array from '../../array/module.f.mjs'
-
-/**
- * @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 =>
-    /** @type {typeof item extends PathItem<infer T> ? _.Node<T> : never} */(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>} */
-export const find = c => {
-    const i3 = index3(c)
-    const i5 = 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(null)
-}
-
-/** @type {<T>(first: First<T>) => boolean} */
-export const isFound = ([i]) => {
-    switch (i) {
-        case 1: case 3: { return true }
-        default: { return false }
-    }
-}
-
-/** @type {<T>(first: First<T>) => T | null} */
-export const value = ([i, r]) => {
-    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/types/module.f.mjs

@@ -1,64 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-
-/**
- * @template T
- * @typedef {readonly[T]} Array1
- */
-
-/**
- * @template T
- * @typedef {readonly[T,T]} Array2
- */
-
-/**
- * @template T
- * @typedef {readonly[T,T,T]} Array3
- */
-
-/** @typedef {0|1} Index2 */
-
-/** @typedef {0|1|2} Index3 */
-
-/** @typedef {0|1|2|3|4} Index5 */
-
-//
-
-/**
- * @template T
- * @typedef {Array1<T>} Leaf1
- */
-
-/**
- * @template T
- * @typedef {Array2<T>} Leaf2
- */
-
-/**
- * @template T
- * @typedef {readonly [Node<T>, T, Node<T>]} Branch3
- */
-
-/**
- * @template T
- * @typedef {readonly [Node<T>, T, Node<T>, T, Node<T>]} Branch5
- */
-
-/**
- * @template T
- * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
- */
-
-/**
- * @template T
- * @typedef {Node<T> | null} Tree
- */
-
-/**
- * @template T
- * @typedef {readonly[Node<T>]} Branch1
- */
-
-/**
- * @template T
- * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
- */

package/types/byte_set/module.f.mjs

@@ -1,61 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as f from '../function/module.f.mjs'
-const { compose } = f
-import * as RangeMap from '../range_map/module.f.mjs'
-import * as SortedSet from '../sorted_set/module.f.mjs'
-import * as list from '../list/module.f.mjs'
-const { reverse, countdown, flat, map } = list
-
-/** @typedef {bigint} ByteSet */
-/** @typedef {number} Byte */
-
-/** @type {(n: Byte) => (s: ByteSet) => boolean} */
-export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
-
-// create a set
-
-export const empty = 0n
-
-//                        0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-export const universe = 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFFn
-
-/** @type {(n: Byte) => ByteSet} */
-export const one = n => 1n << BigInt(n)
-
-/** @type {(r: readonly[Byte, Byte]) => ByteSet} */
-export const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b)
-
-// set operations
-
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-export const union = a => b => a | b
-
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-const intersect = a => b => a & b
-
-/** @type {(n: ByteSet) => ByteSet} */
-export const complement = n => universe ^ n
-
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-const difference = compose(intersect)(compose(complement))
-
-// additional operations
-
-export const set = compose(one)(union)
-
-export const setRange = compose(range)(union)
-
-/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
-export const unset = n => s => difference(s)(one(n))
-
-const counter = reverse(countdown(256))
-
-/** @type {(n: ByteSet) => (s: string) => (i: number) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-const toRangeMapOp = n => s => i => {
-    const current = has(i + 1)(n)
-    const prev = has(i)(n)
-    return current === prev ? null : [[prev ? [s] : [], i]]
-}
-
-/** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-export const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter))

package/types/function/compare/module.f.mjs

@@ -1,29 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Array from '../../array/module.f.mjs'
-
-/** @typedef {Array.Index3} Index3 */
-/** @typedef {Array.Index5} Index5 */
-
-/**
- * @template T
- * @typedef {Array.Array2<T>} Array2
- */
-
-/** @typedef {-1|0|1} Sign */
-
-/**
- * @template T
- * @typedef {(_: T) => Sign} Compare
- */
-
-/** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
-export const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
-
-/** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
-export const index5 = cmp => ([v0, v1]) => {
-    const _0 = cmp(v0)
-    return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3)
-}
-
-/** @type {<T>(a: T) => (b: T) => Sign} */
-export const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0

package/types/function/module.f.mjs

@@ -1,50 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-
-/**
- * A generic function type.
- *
- * @template I
- * @template O
- * @typedef {(_: I) => O} Func
- */
-
-/**
- * A postfix compose function.
- *
- * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
- */
-export const compose = g => f => x => f(g(x))
-
-/**
- * A generic identity function.
- *
- * @type {<T>(value: T) => T}
- */
-export const identity = value => value
-
-/**
- * Flips the arguments of a curried function.
- *
- * @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C}
- */
-export const flip = f => b => a => f(a)(b)
-
-/**
- * A functional utility type that enables seamless chaining of transformations.
- *
- * @template I,O
- * @typedef {{
- *  readonly result: Func<I, O>
- *  readonly then: <T>(g: Func<O, T>) => Fn<I, T>
- * }} Fn
- */
-
-/**
- * Creates an `Fn` instance from a function, enabling chaining of transformations.
- *
- * @type {<I, O>(f: (i: I) => O) => Fn<I, O>}
- */
-export const fn = result => ({
-    result,
-    then: g => fn(compose(result)(g))
-})

package/types/function/operator/module.f.mjs

@@ -1,78 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * @template A
- * @template B
- * @template R
- * @typedef {(a: A) => (b: B) => R} Binary
- */
-
-/**
- * @template I,O
- * @typedef {Binary<I, O, O>} Fold
- */
-
-/** @type {(separator: string) => Reduce<string>} */
-export const join = separator => value => prior => `${prior}${separator}${value}`
-
-/** @type {Reduce<string>} */
-export const concat = i => acc => `${acc}${i}`
-
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => R} Unary
- */
-
-/** @type {Unary<boolean, boolean>} */
-export const logicalNot = v => !v
-
-/**
- * @template T
- * @typedef {Binary<T, T, boolean>} Equal
- */
-
-/** @type {<T>(a: T) => (b: T) => boolean} */
-export const strictEqual = a => b => a === b
-
-/**
- * @template I,O
- * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
- */
-
-/**
- * @template I,S,O
- * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
- */
-
-/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-export const stateScanToScan = op => prior => i => {
-    const [o, s] = op(prior)(i)
-    return [o, stateScanToScan(op)(s)]
-}
-
-/** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-export const foldToScan = fold => prior => i => {
-    const result = fold(i)(prior)
-    return [result, foldToScan(fold)(result)]
-}
-
-/**
- * @template T
- * @typedef {Fold<T, T>} Reduce
- */
-
-/** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-export const reduceToScan = op => init => [init, foldToScan(op)(init)]
-
-/** @type {Reduce<number>} */
-export const addition = a => b => a + b
-
-/** @type {Reduce<number>} */
-export const min = a => b => a < b ? a : b
-
-/** @type {Reduce<number>} */
-export const max = a => b => a > b ? a : b
-
-export const increment = addition(1)
-
-export const counter = () => increment

package/types/function/test.f.mjs

@@ -1,17 +0,0 @@
-import * as _ from './module.f.mjs'
-
-const { fn } = _
-
-export default () => {
-    /** @type {(x: string) => readonly[string]} */
-    const f = x => [x]
-    /** @type {(x: readonly[string]) => readonly[number]} */
-    const g = ([x]) => [x.length]
-    /** @type {(x: readonly[number]) => number} */
-    const w = ([x]) => x
-
-    const r = fn(f).then(g).then(w).result
-
-    const result = r('hello')
-    if (result !== 5) { throw r }
-}