functionalscript 0.2.6 → 0.3.1

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

package/types/sorted_list/module.f.mjs

@@ -1,107 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as compare from '../function/compare/module.f.mjs'
-import * as list from '../list/module.f.mjs'
-import * as option from '../nullable/module.f.mjs'
-const { next } = list
-import * as f from '../function/module.f.mjs'
-const { identity } = f
-
-/**
- * @template T
- * @typedef {list.List<T>} SortedList
- */
-
-/**
- * @template T
- * @typedef {readonly T[]} SortedArray
- */
-
-/**
- * @template T
- * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
- */
-
-/**
- * @template T
- * @template S
- * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]} ReduceOp
- */
-
-/**
- * @template T
- * @template S
- * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
- */
-
-/**
- * @template T
- * @template S
-  * @typedef {{
- *  readonly reduceOp: ReduceOp<T,S>
- *  readonly tailReduce: TailReduce<T,S>
-  * }} MergeReduce
- */
-
-/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-export const genericMerge = ({ reduceOp, tailReduce }) => {
-    /** @typedef {typeof reduceOp extends ReduceOp<infer T, infer S> ? [T, S] : never} TS */
-    /** @typedef {TS[0]} T */
-    /** @typedef {TS[1]} S */
-    /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
-    const f = state => a => b => () => {
-        const aResult = next(a)
-        if (aResult === null) { return tailReduce(state)(b) }
-        const bResult = next(b)
-        if (bResult === null) { return tailReduce(state)(aResult) }
-        const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
-        const aNext = sign === 1 ? a : aResult.tail
-        const bNext = sign === -1 ? b : bResult.tail
-        const tail = f(stateNext)(aNext)(bNext)
-        return first === null ? tail : { first, tail }
-    }
-    return f
-}
-
-/**
- * @template T
- * @typedef {ReduceOp<T, null>} CmpReduceOp
- */
-
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
-export const merge = cmp => {
-    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
-    /** @type {TailReduce<T, null>} */
-    const tailReduce = mergeTail
-    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null)
-}
-
-/** @type {<T>(cmp: Cmp<T>) => CmpReduceOp<T>} */
-const cmpReduce = cmp => () => a => b => {
-    const sign = cmp(a)(b)
-    return [sign === 1 ? b : a, sign, null]
-}
-
-/** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
-const mergeTail = () => identity
-
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null} */
-export const find = cmp => value => array => {
-    let b = 0
-    let e = array.length - 1
-    while (true) {
-        if (e - b < 0) return null
-        const mid = b + (e - b >> 1)
-        const sign = cmp(value)(array[mid])
-        switch(sign) {
-            case -1: {
-                 e = mid - 1
-                 break
-            }
-            case 0: { return value }
-            case 1: {
-                 b = mid + 1
-                 break
-            }
-        }
-    }
-}

package/types/sorted_set/module.f.mjs

@@ -1,38 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Compare from '../function/compare/module.f.mjs'
-import * as list from "../list/module.f.mjs"
-const { toArray } = list
-import * as sortedList from '../sorted_list/module.f.mjs'
-const { merge, genericMerge, find } = sortedList
-
-/**
- * @template T
- * @typedef {readonly T[]} SortedSet
- */
-
-/**
- * @template T
- * @typedef {(a: T) => (b: T) => Compare.Sign} Cmp
- */
-
-/** @typedef {number} Byte */
-
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-export const union = cmp => a => b => toArray(merge(cmp)(a)(b))
-
-/** @type {<T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>} */
-export const intersect = cmp => a => b => toArray(intersectMerge(cmp)(a)(b))
-
-const tailReduce = () => () => null
-
-/** @type {<T>(cmp: Cmp<T>) => (a: sortedList.SortedList<T>) => (b: sortedList.SortedList<T>) => sortedList.SortedList<T>} */
-const intersectMerge = cmp => genericMerge({ reduceOp: intersectReduce(cmp), tailReduce })(null)
-
-/** @type {<T,S>(cmp: Cmp<T>) => sortedList.ReduceOp<T,S>} */
-const intersectReduce = cmp => state => a => b => {
-    const sign = cmp(a)(b)
-    return [sign === 0 ? a : null, sign, state]
-}
-
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean} */
-export const has = cmp => value => set => find(cmp)(value)(set) === value

package/types/string/module.f.mjs

@@ -1,22 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../list/module.f.mjs'
-const { reduce: listReduce, repeat: listRepeat } = list
-import * as f from '../function/module.f.mjs'
-const { compose } = f
-import * as compare from '../function/compare/module.f.mjs'
-const { unsafeCmp } = compare
-import * as op from '../function/operator/module.f.mjs'
-const { join: joinOp, concat: concatOp } = op
-
-/** @type {(o: op.Reduce<string>) => (input: list.List<string>) => string} */
-const reduce = o => listReduce(o)('')
-
-export const join = compose(joinOp)(reduce)
-
-export const concat = reduce(concatOp)
-
-/** @type {(n: string) => (v: number) => string} */
-export const repeat = v => compose(listRepeat(v))(concat)
-
-/** @type {(a: string) => (b: string) => compare.Sign} */
-export const cmp = unsafeCmp

package/types/string_set/module.f.mjs

@@ -1,36 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as BtreeTypes from '../btree/types/module.f.mjs'
-import * as btree from '../btree/module.f.mjs'
-import * as btf from '../btree/find/module.f.mjs'
-const { find, isFound } = btf
-import * as btr from '../btree/remove/module.f.mjs'
-const { remove: btreeRemove } = btr
-import * as bts from '../btree/set/module.f.mjs'
-const { set: btreeSet } = bts
-export const {
-    /** @type {(s: StringSet) => list.List<string>} */
-    values,
-    empty,
-} = btree
-import * as string from "../string/module.f.mjs"
-const { cmp } = string
-import * as list from '../list/module.f.mjs'
-const { fold } = list
-import * as f from '../function/module.f.mjs'
-const { compose } = f
-
-/** @typedef {BtreeTypes.Tree<string>} StringSet */
-
-/** @type {(value: string) => (set: StringSet) => boolean} */
-export const contains = value => {
-    const f = find(cmp(value))
-    return s => s !== null && isFound(f(s).first)
-}
-
-/** @type {(value: string) => (s: StringSet) => StringSet} */
-export const set = value => btreeSet(cmp(value))(() => value)
-
-export const fromValues = fold(set)(null)
-
-/** @type {(value: string) => (s: StringSet) => StringSet} */
-export const remove = compose(cmp)(btreeRemove)