functionalscript 0.2.5 → 0.3.0

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

package/types/nibble_set/module.f.mjs

@@ -1,28 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/** @typedef {number} NibbleSet */
-/** @typedef {number} Nibble */
-
-export const empty = 0
-
-export const universe = 0xFFFF
-
-/** @type {(n: Nibble) => NibbleSet} */
-const one = n => 1 << n
-
-/** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
-export const has = n => s => ((s >> n) & 1) === 1
-
-/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
-export const set = n => s => s | one(n)
-
-/** @type {(n: NibbleSet) => NibbleSet} */
-export const complement = s => universe ^ s
-
-/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
-export const unset = n => s => s & complement(one(n))
-
-/** @type {(r: readonly[number, number]) => NibbleSet} */
-const range = ([a, b]) => one(b - a + 1) - 1 << a
-
-/** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
-export const setRange = r => s => s | range(r)

package/types/nullable/module.f.mjs

@@ -1,11 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * @template T
- * @typedef {T|null} Nullable
- */
-
-/** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
-export const map = f => value => value === null ? null : f(value)
-
-/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
-export const match = f => none => value => value === null ? none() : f(value)

package/types/number/module.f.mjs

@@ -1,16 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../list/module.f.mjs'
-const { reduce } = list
-import * as operator from '../function/operator/module.f.mjs'
-const { addition, min: minOp, max: maxOp } = operator
-import * as compare from '../function/compare/module.f.mjs'
-const { unsafeCmp } = compare
-
-export const sum = reduce(addition)(0)
-
-export const min = reduce(minOp)(null)
-
-export const max = reduce(maxOp)(null)
-
-/** @type {(a: number) => (b: number) => compare.Sign} */
-export const cmp = unsafeCmp

package/types/object/module.f.mjs

@@ -1,33 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../list/module.f.mjs'
-const { iterable } = list
-import * as btMap from '../map/module.f.mjs'
-const { entries: mapEntries, fromEntries: mapFromEntries } = btMap
-const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object
-
-/**
- * @template T
- * @typedef {{
- *  readonly [k in string]: T
- * }} Map
- */
-
-/**
- * @template T
- * @typedef {readonly[string, T]} Entry
- */
-
-/** @type {(name: string) => <T>(object: Map<T>) => T|null} */
-export const at = name => object => {
-    const r = getOwnPropertyDescriptor(object, name)
-    return r === void 0 ? null : r.value
-}
-
-/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
-export const sort = e => mapEntries(mapFromEntries(e))
-
-/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
-export const fromEntries = e => objectFromEntries(iterable(e))
-
-/** @type {<T>(m: btMap.Map<T>) => Map<T>} */
-export const fromMap = m => fromEntries(mapEntries(m))

package/types/range/module.f.mjs

@@ -1,8 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/** @typedef {readonly[number,number]} Range */
-
-/** @type {(range: Range) => (i: number) => boolean} */
-export const contains = ([b, e]) => i => b <= i && i <= e
-
-/** @type {(i: number) => Range} */
-export const one = a => [a, a]

package/types/range_map/module.f.mjs

@@ -1,84 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as sortedList from '../sorted_list/module.f.mjs'
-const { genericMerge } = sortedList
-import * as list from '../list/module.f.mjs'
-const { next } = list
-import * as Option from '../nullable/module.f.mjs'
-import * as number from '../number/module.f.mjs'
-const { cmp } = number
-import * as O from '../function/operator/module.f.mjs'
-import * as Range from '../range/module.f.mjs'
-
-/**
- * @template T
- * @typedef {[T, number]} Entry
- */
-
-/**
- * @template T
- * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
- */
-
-/**
- * @template T
- * @typedef {readonly Entry<T>[]} RangeMapArray
- */
-
-/**
- * @template T
- * @typedef {{
- *  readonly union: O.Reduce<T>
- *  readonly equal: O.Equal<T>
- * }} Operators
- */
-
-/**
- * @template T
- * @typedef {Option.Nullable<Entry<T>>} RangeState
- */
-
-/**
- * @template T
- * @typedef {O.Reduce<RangeMap<T>>} RangeMerge
- */
-
-/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>} */
-const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
-    const sign = cmp(aMax)(bMax)
-    const min = sign === 1 ? bMax : aMax
-    const u = union(aItem)(bItem)
-    const newState = state !== null && equal(state[0])(u) ? null : state
-    return [newState, sign, [u, min]]
-}
-
-/** @type {<T>(equal: O.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
-const tailReduce = equal => state => tail => {
-    if (state === null) { return tail }
-    const tailResult = next(tail)
-    if (tailResult === null) { return [state] }
-    if (equal(state[0])(tailResult.first[0])) { return tailResult }
-    return { first: state, tail: tailResult }
-}
-
-/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-export const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null)
-
-/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
-export const get = def => value => rm => {
-    const len = rm.length
-    let b = 0
-    let e = len - 1
-    while (true) {
-        if (b >= len) { return def }
-        if (e - b < 0) { return rm[b][0] }
-        const mid = b + (e - b >> 1)
-        if (value <= rm[mid][1]) {
-            e = mid - 1
-        } else {
-            b = mid + 1
-        }
-    }
-}
-
-/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
-export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]]

package/types/result/module.f.mjs

@@ -1,28 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * @template T
- * @typedef {readonly['ok', T]} Ok
- */
-
-/**
- * @template E
- * @typedef {readonly['error', E]} Error
- */
-
-/**
- * @template T
- * @template E
- * @typedef {Ok<T>|Error<E>} Result
- */
-
-/** @type {<T>(value: T) => Ok<T>} */
-export const ok = value => ['ok', value]
-
-/** @type {<E>(e: E) => Error<E>} */
-export const error = e => ['error', e]
-
-/** @type {<T, E>(r: Result<T, E>) => T} */
-export const unwrap = ([kind, v]) => {
-    if (kind === 'error') { throw v }
-    return v
-}