functionalscript 0.2.6 → 0.3.0

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 }
-}

package/types/list/module.f.mjs

@@ -1,320 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as function_ from '../function/module.f.mjs'
-const { identity, fn, compose } = function_
-import * as operator from '../function/operator/module.f.mjs'
-const {
-    addition,
-    logicalNot,
-    strictEqual,
-    stateScanToScan,
-    foldToScan,
-    reduceToScan
-} = operator
-
-/**
- * @template T
- * @typedef {NotLazy<T> | Thunk<T>} List
- */
-
-/**
- * @template T
- * @typedef {|
- *  Result<T> |
- *  Concat<T> |
- *  readonly T[]
- * } NotLazy
- */
-
-/** @typedef {null} Empty */
-
-/**
- * @template T
- * @typedef {Empty | NonEmpty<T>} Result
- */
-
-/**
- * @template T
- * @typedef {() => List<T>} Thunk
- */
-
-/**
- * @template T
- * @typedef {{
- *  readonly first: T
- *  readonly tail: List<T>
- * }} NonEmpty
- */
-
-/**
- * @template T
- * @typedef {{
- *  readonly head: List<T>
- *  readonly tail: List<T>
- * }} Concat
- */
-
-/** @type {<T>(array: readonly T[]) => Result<T>} */
-const fromArray = array => {
-    /** @typedef {typeof array extends readonly (infer T)[] ? T : never} T */
-    /** @type {(i: number) => Result<T>} */
-    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null
-    return at(0)
-}
-
-/** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
-export const concat = head => tail => tail === null ? head : ({ head, tail })
-
-/** @type {<T>(list: List<T>) => NotLazy<T> } */
-const trampoline = list => {
-    while (typeof list === 'function') { list = list() }
-    return list
-}
-
-/** @type {<T>(list: List<T>) => Result<T>} */
-export const next = head => {
-    /** @type {typeof head} */
-    let tail = null
-    while (true) {
-        head = trampoline(head)
-
-        if (head instanceof Array) {
-            head = fromArray(head)
-        } else if (head !== null && 'head' in head) {
-            [head, tail] = [head.head, concat(head.tail)(tail)]
-            continue
-        }
-
-        if (head !== null) {
-            return { first: head.first, tail: concat(head.tail)(tail) }
-        }
-
-        if (tail === null) { return null }
-
-        [head, tail] = [tail, null]
-    }
-}
-
-/** @type {<T>(list: List<T>) => Iterable<T>} */
-export const iterable = list => ({
-    *[Symbol.iterator]() {
-        let i = list
-        while (true) {
-            const r = next(i)
-            if (r === null) { return }
-            yield r.first
-            i = r.tail
-        }
-    }
-})
-
-const { from } = Array
-
-/** @type {<T>(list: List<T>) => readonly T[]} */
-export const toArray = list => {
-    const u = trampoline(list)
-    return u instanceof Array ? u : from(iterable(u))
-}
-
-/** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => Thunk<O>} */
-const apply = f => input => () => {
-    const n = next(input)
-    if (n === null) { return null }
-    return f(n)
-}
-
-/** @type {<T>(n: NonEmpty<List<T>>) => List<T>} */
-const flatStep = ({ first, tail }) => concat(first)(flat(tail))
-
-/** @type {<T>(list: List<List<T>>) => Thunk<T>} */
-export const flat = apply(flatStep)
-
-/** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
-const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
-
-/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
-export const map = f => apply(mapStep(f))
-
-/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
-export const flatMap = f => compose(map(f))(flat)
-
-/** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
-const filterStep = f => ({ first, tail }) => {
-    const newTail = filter(f)(tail)
-    return f(first) ? { first, tail: newTail } : newTail
-}
-
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-export const filter = f => apply(filterStep(f))
-
-/** @type {<I, O>(f: (value: I) => O|null) => (n: NonEmpty<I>) => List<O>} */
-const filterMapStep = f => n => {
-    const [first, tail] = [f(n.first), filterMap(f)(n.tail)]
-    return first === null ? tail : { first, tail }
-}
-
-/** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
-export const filterMap = f => apply(filterMapStep(f))
-
-/** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
-const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null
-
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-export const takeWhile = f => apply(takeWhileStep(f))
-
-/** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
-const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null
-
-/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-export const take = n => apply(takeStep(n))
-
-/** @type {<T>(f: (value: T) => boolean) => (ne: NonEmpty<T>) => List<T>} */
-const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne
-
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-export const dropWhile = f => apply(dropWhileStep(f))
-
-/** @type {(n: number) => <T>(ne: NonEmpty<T>) => List<T>} */
-const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne
-
-/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-export const drop = n => apply(dropStep(n))
-
-/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
-export const first = def => input => {
-    const ne = next(input)
-    return ne === null ? def : ne.first
-}
-
-/** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
-export const last = first => tail => {
-    /** @typedef {typeof tail extends List<infer T> ? T : never} T */
-    /** @type {NonEmpty<typeof first|T>} */
-    let i = { first, tail }
-    while (true) {
-        const result = next(i.tail)
-        if (result === null) {
-            return i.first
-        }
-        i = result
-    }
-}
-
-/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-export const find = def => f => compose(filter(f))(first(def))
-
-/** @type {(input: List<boolean>) => boolean} */
-export const some = find(false)(identity)
-
-/** @type {<T>(input: List<T>) => boolean} */
-export const isEmpty = fn(map(() => true))
-    .then(some)
-    .then(logicalNot)
-    .result
-
-export const every = fn(map(logicalNot))
-    .then(some)
-    .then(logicalNot)
-    .result
-
-/** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-export const includes = value => compose(map(strictEqual(value)))(some)
-
-/** @type {(count: number) => Thunk<number>} */
-export const countdown = count => () => {
-    if (count <= 0) { return null }
-    const first = count - 1
-    return { first, tail: countdown(first) }
-}
-
-/** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-export const repeat = v => compose(countdown)(map(() => v))
-
-/** @type {<T>(list: List<T>) => List<T>} */
-export const cycle = list => () => {
-    const i = next(list)
-    return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) }
-}
-
-/** @type {<I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
-const scanStep = op => ne => {
-    const [first, newOp] = op(ne.first)
-    return { first, tail: scan(newOp)(ne.tail) }
-}
-
-/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
-export const scan = op => apply(scanStep(op))
-
-/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-export const stateScan = op => compose(stateScanToScan(op))(scan)
-
-/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-export const foldScan = op => compose(foldToScan(op))(scan)
-
-/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-export const fold = op => init => compose(foldScan(op)(init))(last(init))
-
-/** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-export const reduce = op => def => compose(scan(reduceToScan(op)))(last(def))
-
-/** @type {<T>(list: List<T>) => Thunk<number>} */
-const lengthList = list => () => {
-    const notLazy = trampoline(list)
-    if (notLazy === null) { return null }
-    if (notLazy instanceof Array) { return [notLazy.length] }
-    const tail = lengthList(notLazy.tail)
-    if ("first" in notLazy) {
-        return { first: 1, tail }
-    }
-    return { head: lengthList(notLazy.head), tail }
-}
-
-const sum = reduce(addition)(0)
-
-/** @type {<T>(input: List<T>) => number} */
-export const length = compose(lengthList)(sum)
-
-/**
- * @template T
- * @typedef {readonly[number, T]} Entry
- */
-
-/** @type {(index: number) => <T>(value: T) => readonly[Entry<T>, number]} */
-const entryOperator = index => value => [[index, value], index + 1]
-
-/** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
-export const entries = input => {
-    /** @typedef {typeof input extends List<infer T> ? T : never} T */
-    /** @type {operator.StateScan<T, Number, Entry<T>>} */
-    const o = entryOperator
-    return stateScan(o)(0)(input)
-}
-
-/** @type {<T>(value: T) => (prior: List<T>) => List<T>} */
-const reverseOperator = first => tail => ({ first, tail })
-
-/** @type {<T>(input: List<T>) => List<T>} */
-export const reverse = fold(reverseOperator)(null)
-
-/** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
-export const zip = a => b => () => {
-    const aResult = next(a)
-    if (aResult === null) { return null }
-    const bResult = next(b)
-    if (bResult === null) { return null }
-    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
-}
-
-/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-export const equal = e => {
-    /** @typedef {typeof e extends operator.Equal<infer T> ? T : never} T */
-    /** @type {(a: List<T>) => (b: List<T>) => List<boolean>} */
-    const f = a => b => () => {
-        const [aResult, bResult] = [next(a), next(b)]
-        return aResult === null || bResult === null
-            ? { first: aResult === bResult, tail: null }
-            : { first: e(aResult.first)(bResult.first), tail: f(aResult.tail)(bResult.tail) }
-    }
-    return a => b => every(f(a)(b))
-}
-
-export const empty = null

package/types/map/module.f.mjs

@@ -1,67 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as BtreeTypes from '../btree/types/module.f.mjs'
-import * as btf from '../btree/find/module.f.mjs'
-const { value, find } = btf
-import * as bts from '../btree/set/module.f.mjs'
-const { set } = bts
-import * as btr from '../btree/remove/module.f.mjs'
-const { remove: btreeRemove } = btr
-import * as bt from '../btree/module.f.mjs'
-const { values } = bt
-import * as Compare from '../function/compare/module.f.mjs'
-import * as s from '../string/module.f.mjs'
-const { cmp } = s
-import * as list from '../list/module.f.mjs'
-const { fold } = list
-import * as Operator from '../function/operator/module.f.mjs'
-
-/** @typedef {Compare.Sign} Sign */
-
-/**
- * @template T
- * @typedef {Compare.Compare<T>} Cmp
- */
-
-/**
- * @template T
- * @typedef {readonly[string, T]} Entry
- */
-
-/**
- * @template T
- * @typedef {BtreeTypes.Tree<Entry<T>>} Map
- */
-
-/** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
-const keyCmp = a => ([b]) => cmp(a)(b)
-
-/** @type {(name: string) => <T>(map: Map<T>) => T|null} */
-export const at = name => map => {
-    if (map === null) { return null }
-    const result = value(find(keyCmp(name))(map).first)
-    return result === null ? null : result[1]
-}
-
-/** @type {<T>(reduce: Operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>} */
-const setReduceEntry = reduce => entry =>
-    set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])])
-
-/** @type {<T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
-export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value])
-
-/** @type {<T>(a: T) => (b: T) => T} */
-const replace = () => b => b
-
-/** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
-export const setReplace = name => value => setReduceEntry(replace)([name, value])
-
-/** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */
-export const entries = values
-
-/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
-export const fromEntries = fold(setReduceEntry(replace))(null)
-
-/** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
-export const remove = name => btreeRemove(keyCmp(name))
-
-export const empty = null