functionalscript 0.0.229 → 0.0.233

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