functionalscript 0.3.4 → 0.3.5

package/types/byte_set/test.f.ts

@@ -1,84 +0,0 @@
-import * as _ from './module.f.ts'
-import * as list from '../list/module.f.ts'
-const { every, countdown, map, toArray } = list
-import * as json from '../../json/module.f.ts'
-import * as o from '../object/module.f.ts'
-const { sort } = o
-
-const stringify
-    : (a: readonly json.Unknown[]) => string
-    = json.stringify(sort)
-
-export default {
-    has: [
-        () => {
-            if (_.has(0)(_.empty)) { throw _.empty }
-            if (_.has(1)(_.empty)) { throw _.empty }
-            if (_.has(33)(_.empty)) { throw _.empty }
-        },
-        () => {
-            const s = _.set(0)(_.empty)
-            if (s !== 1n) { throw s }
-            if (!_.has(0)(s)) { throw s }
-            if (_.has(1)(s)) { throw s }
-            if (_.has(33)(s)) { throw s }
-        },
-        () => {
-            const s = _.set(33)(_.empty)
-            if (s !== 8589934592n) { throw s }
-            if (_.has(0)(s)) { throw s }
-            if (_.has(1)(s)) { throw s }
-            if (!_.has(33)(s)) { throw s }
-        }
-    ],
-    setRange: () => {
-        const result = _.setRange([2, 5])(_.empty)
-        if (result !== 60n) { throw result }
-    },
-    unset: [
-        () => {
-            const a = _.set(0)(_.empty)
-            const result = _.unset(0)(a)
-            if (result !== 0n) { throw result }
-        },
-        () => {
-            const a = _.set(255)(_.empty)
-            const result = _.unset(255)(a)
-            if (result !== 0n) { throw result }
-        }
-    ],
-    universe: () => {
-        const x = every(map((v: any) => _.has(v)(_.universe))(countdown(256)))
-        if (!x) { throw x }
-    },
-    compliment: {
-        empty: () => {
-            const r = _.complement(_.empty)
-            if (r !== _.universe) { throw r }
-        },
-        universe: () => {
-            const r = _.complement(_.universe)
-            if (r !== _.empty) { throw r }
-        },
-    },
-    toRangeMap: [
-        () => {
-            const result = stringify(toArray(_.toRangeMap(_.empty)('a')))
-            if (result !== '[]') { throw result }
-        },
-        () => {
-            const s = _.set(0)(_.empty)
-            const result = stringify(toArray(_.toRangeMap(s)('a')))
-            if (result !== '[[["a"],0]]') { throw result }
-        },
-        () => {
-            const s = _.setRange([1,2])(_.empty)
-            const result = stringify(toArray(_.toRangeMap(s)('a')))
-            if (result !== '[[[],0],[["a"],2]]') { throw result }
-        },
-        () => {
-            const result = stringify(toArray(_.toRangeMap(_.universe)('a')))
-            if (result !== '[[["a"],255]]') { throw result }
-        },
-    ]
-}

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

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

package/types/function/compare/test.f.ts

@@ -1,7 +0,0 @@
-import * as _ from './module.f.ts'
-const { unsafeCmp } = _
-
-export default () => {
-    const result = unsafeCmp(true)(false)
-    if (result !== 1) { throw result }
-}

package/types/function/module.f.ts

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

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

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

package/types/function/test.f.ts

@@ -1,20 +0,0 @@
-import * as _ from './module.f.ts'
-
-const { fn } = _
-
-export default () => {
-    const f
-        : (x: string) => readonly[string]
-        = x => [x]
-    const g
-        : (x: readonly[string]) => readonly[number]
-        = ([x]) => [x.length]
-    const w
-        : (x: readonly[number]) => number
-        = ([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.ts

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