functionalscript 0.0.230 → 0.0.234

package/sequence/asyncIterable/index.js

@@ -1,111 +0,0 @@
-const { compose } = require('../../function')
-const seq = require('../operator')
-
-/**
- * @template T 
- * @typedef {Promise<T>|T} PromiseOrValue 
- */
-
-/**
- * @template T
- * @typedef {Iterable<T> | AsyncIterable<T>} AsyncOrSyncIterable
- */
-
-/** @type {<T>(c: AsyncOrSyncIterable<AsyncOrSyncIterable<T>>) => AsyncIterable<T>} */
-const flat = c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield* i
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => AsyncOrSyncIterable<R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield* await f(i)
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => R) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const map = seq.map(flatMap)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncOrSyncIterable<T>} */
-const filter = seq.filter(flatMap)
-
-/** @type {<T>(a: AsyncOrSyncIterable<T>) => (b: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
-const concat = a => b => ({
-    async *[Symbol.asyncIterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<T, R>(s: seq.Scan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const scan = s => c => ({
-    async *[Symbol.asyncIterator]() {
-        let next = s
-        for await (const i of c) {
-            const result = next(i)
-            next = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
-const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
-
-/** @type {<T, R>(is: seq.ExclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
-const reduce = ([first, s]) => async c => {
-    let next = first
-    for await (const i of scan(s)(c)) {
-        next = i
-    }
-    return next
-}
-
-const sum = reduce(seq.sum)
-
-const join = compose(seq.join)(reduce)
-
-const length = reduce(seq.length)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
-const takeWhile = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            if (!f(i)) { return }
-            yield i
-        }
-    }
-})
-
-module.exports = {
-    /** @readonly */
-    concat,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    join,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    takeWhile,
-}

package/sequence/asyncIterable/test.js

@@ -1,24 +0,0 @@
-const { map, filter, flatMap, sum } = require('.')
-
-const test = async () => {
-    {
-        const a = [1, 2, 3]
-        const m = map(x => x * x)(a)
-        const result = await sum(m)
-        if (result !== 14) { throw 'filter' }
-    }
-    {
-        const a = [1, 2, 3, 4]
-        const f = filter(x => x !== 2)(a)
-        const result = await sum(f)
-        if (result !== 8) { throw 'filter' }
-    }
-    {
-        const a = [1, 2]
-        const f = flatMap(x => [x, x * x])(a)
-        const result = await sum(f)
-        if (result !== 8) { throw 'filter' }
-    }
-}
-
-test()

package/sequence/iterable/index.js

@@ -1,109 +0,0 @@
-const { compose } = require('../../function')
-const seq = require('../operator')
-
-/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
-const concat = a => b => ({
-    *[Symbol.iterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<T, R>(s: seq.Scan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const scan = s => c => ({
-    *[Symbol.iterator]() {
-        let next = s
-        for (const i of c) {
-            const result = next(i)
-            next = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const exclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
-
-/** @type {<T, R>(s: seq.ExclusiveScan<T, R>) => (c: Iterable<T>) => R} */
-const reduce = ([first, s]) => c => {
-    let next = first
-    for (const i of scan(s)(c)) {
-        next = i
-    }
-    return next
-}
-
-const entries = scan(seq.entries)
-
-const sum = reduce(seq.sum)
-
-const length = reduce(seq.length)
-
-const join = compose(seq.join)(reduce)
-
-/** @type {<T, R>(f: (value: T) => Iterable<R>) => (c: Iterable<T>) => Iterable<R>} */
-const flatMap = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            yield* f(i)
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
-const map = seq.map(flatMap)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
-const filter = seq.filter(flatMap)
-
-/** @type {<T>(c: Iterable<Iterable<T>>) => Iterable<T>} */
-const flat = flatMap(x => x)
-
-/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
-const takeWhile = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            if (!f(i)) { return }
-            yield i
-        }
-    }
-})
-
-/** @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} */
-const find = f => c => {
-    for (const i of c) {
-        if (f(i)) {
-            return i
-        }
-    }
-    return undefined
-}
-
-module.exports = {
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    join,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    takeWhile,
-    /** @readonly */
-    find,
-}

package/sequence/iterable/test.js

@@ -1,51 +0,0 @@
-const i = require('.')
-const { compose } = require('../../function')
-
-{
-    const r = i.sum([120, 300, 42])
-    if (r !== 462) { throw 'error' }
-}
-
-{
-    if (i.sum([1, 2]) !== 3) { throw 'error' }
-    if (i.sum([1, 2]) !== 3) { throw 'error' }
-}
-
-{
-    const x = Array.from(i.map(a => a ** 2)([1, 2, 3]))
-    if (x.length !== 3) { throw 'error' }
-    if (x[0] !== 1) { throw 'error' }
-    if (x[1] !== 4) { throw 'error' }
-    if (x[2] !== 9) { throw 'error' }
-}
-
-{
-    if (i.join('/')([]) !== '') { throw 'error' }
-    if (i.join('/')(['a']) !== 'a') { throw 'error' }
-    if (i.join('/')(['a', 'b']) !== 'a/b') { throw 'error'}
-}
-
-{
-    if (i.find(x => x === 'c')(['a', 'b', 'c']) !== 'c') { throw 'error' }
-}
-
-{
-    /** @type {(_: string) => string|undefined} */
-    const file = _ => 'x'
-    /** @type {(_: string) => string|undefined} */
-    const x = p => compose
-        (i.map(x => file(x())))
-        (i.find(x => x !== undefined))                
-        ([() => p, () => `${p}.js`, () => `${p}/index.js`])
-    if (x('index.js') !== 'x') { throw 'error' }
-}
-
-{
-    const x = JSON.stringify(Array.from(i.entries(['a', 'b', 'c'])))
-    if (x !== '[[0,"a"],[1,"b"],[2,"c"]]') { throw x }
-}
-
-{
-    const x = JSON.stringify(Array.from(i.entries([])))
-    if (x !== '[]') { throw x }
-}

package/sequence/operator/index.js

@@ -1,92 +0,0 @@
-const op = require('../../function/operator')
-
-/**
- * @template T0
- * @template T1
- * @typedef {import('../array').Tuple2<T0, T1>} Tuple2
- */
-
-/**
- * @template T
- * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} ScanResult
- */
-
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => ScanResult<T, R>} Scan
- */
-
-/**
- * @template T
- * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} ExclusiveScan
- */
-
-/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (prior: R) => Scan<T, R>} */
-const scan = operator => {
-    /** @typedef {typeof operator extends op.ReduceOperator<infer R, infer T> ? [R, T] : never} RT */
-    /** @typedef {RT[0]} R */
-    /** @typedef {RT[1]} T */
-    /** @type {(prior: R) => Scan<T, R>} */
-    const f = prior => value => {
-        const result = operator(prior)(value)
-        return [result, f(result)]
-    }
-    return f
-}
-
-/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (first: R) => ExclusiveScan<T, R>} */
-const exclusiveScan = operator => first => [first, scan(operator)(first)]
-
-/** 
- * @template T
- * @typedef {Tuple2<number, T>} Entry
- */
-
-/** @type {(index: number) => <T>(value: T) => ScanResult<T, Entry<T>>} */
-const createEntries = index => value => [[index, value], createEntries(index + 1)]
-
-const entries = createEntries(0)
-
-/** @type {(separator: string) => ExclusiveScan<string, string>} */
-const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
-
-const sum = exclusiveScan(op.addition)(0)
-
-/** @type {(a: number) => () => number} */
-const counter = a => () => a + 1
-
-const length = exclusiveScan(counter)(0)
-
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => R} Func
- */
-
-/** @type {<T, R, X>(flatMap: (f: Func<T, readonly[R]>) => X) => (f: Func<T, R>) =>X} */
-const map = flatMap => f => flatMap(x => [f(x)])
-
-/** @type {<T, X>(flatMap: (f: Func<T, readonly[T]|[]>) => X) => (f: Func<T, boolean>) =>X} */
-const filter = flatMap => f => flatMap(x => f(x) ? [x] : [])
-
-module.exports = {
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    join,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    length,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-}