functionalscript 0.0.161 → 0.0.166

package/array/index.js

@@ -17,6 +17,12 @@ const option = require('../option')
  * @typedef {readonly [T, T]} Array2
  */
 
+/**
+ * @template T0
+ * @template T1
+ * @typedef {readonly [T0, T1]} Tuple2
+ */
+
 /** @typedef {0|1} Index2 */
 
 /**

package/async/iterable/index.js

@@ -0,0 +1,121 @@
+const { pipe } = require('../../func')
+const mr = require('../../map-reduce')
+
+/** 
+ * @template T
+ * @typedef {Promise<T>|T} PromiseOrValue
+ */
+
+/** 
+ * @template T
+ * @template R
+ * @typedef {(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} Map
+ */
+
+/**
+ * @template T
+ * @typedef {Iterable<T> | AsyncIterable<T>} AnyIterator
+ */
+
+/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AnyIterator<T>) => AsyncIterable<R>} */
+const map = f => c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            yield f(i)
+        }
+    }
+})
+
+/** @type {<T>(c: AnyIterator<AnyIterator<T>>) => AsyncIterable<T>} */
+const flatten = c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            yield *i
+        }
+    }
+})
+
+/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AnyIterator<T>) => AnyIterator<T>} */
+const filter = f => c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            if (await f(i)) {
+                yield i
+            }
+        }
+    }
+})
+
+/** @type {<T, R>(f: (value: T) => AnyIterator<R>) => (c: AnyIterator<T>) => AsyncIterable<R>} */
+const flatMap = f => pipe(map(f))(flatten)
+
+/** 
+ * @template A
+ * @template T
+ * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
+ */
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => Promise<A>} */
+const reduce = merge => init => async c => {
+    let result = init
+    for await (const i of c) {
+        result = await merge(result)(i)
+    }
+    return result
+}
+
+/** @type {<T>(a: AnyIterator<T>) => (b: AnyIterator<T>) => AsyncIterable<T>} */
+const concat = a => b => ({
+    async *[Symbol.asyncIterator]() {
+        yield* a
+        yield* b
+    }
+})
+
+/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => AsyncIterable<A>} */
+const exclusiveScan = merge => init => c => ({
+    async *[Symbol.asyncIterator]() {
+        let result = init
+        for await (const i of c) {
+            result = await merge(result)(i)
+            yield result
+        }
+    }
+})
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => AsyncIterable<A>} */
+const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
+
+/** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: AnyIterator<I>) => Promise<R>} */
+const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
+
+const sum = apply(mr.sum)
+
+const join = pipe(mr.join)(apply)
+
+const size = apply(mr.size)
+
+module.exports = {
+    /** @readonly */
+    apply,
+    /** @readonly */
+    concat,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    size,
+    /** @readonly */
+    join,
+    /** @readonly */
+    exclusiveScan,
+    /** @readonly */
+    inclusiveScan,
+}

package/async/{test.js → iterable/test.js}

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

package/func/index.js

@@ -1,12 +1,40 @@
-/** @type {<I, X>(_: (_: I) => X) => <O>(_: (_: X) => O) => (_: I) => O} */
+/** 
+ * @template I
+ * @template O
+ * @typedef {(_: I) => O} Func 
+ */
+
+/** @type {<X, O>(f: Func<X, O>) => <I>(g: Func<I, X>) => Func<I, O>} */
+const combine = f => g => x => f(g(x))
+
+/** @type {<I, X>(g: Func<I, X>) => <O>(g: Func<X, O>) => Func<I, O>} */
 const pipe = g => f => x => f(g(x))
 
 /** @type {<T>(value: T) => T} */
 const id = value => value
 
+/**
+ * @template I
+ * @template O
+ * @typedef {{
+ *  readonly pipe: <R>(f: Func<O, R>) => Pipe<I, R>
+ *  readonly call: Func<I, O>
+ * }} Pipe
+ */
+
+/** @type {<I, O>(f: Func<I, O>) => Pipe<I, O>} */
+const pipex = call => ({
+    pipe: f => pipex(pipe(call)(f)),
+    call,
+}) 
+
 module.exports = {
     /** @readonly */
     id,
     /** @readonly */
     pipe,
+    /** @readonly */
+    combine,
+    /** @readonly */
+    pipex,
 }

package/iterable/index.js

@@ -1,7 +1,13 @@
 const { pipe } = require('../func')
 const mr = require('../map-reduce')
 
-/** @type {<T, R>(merge: (_: R) => (_: T) => R) => (init: R) => (_: Iterable<T>) => R} */
+/**
+ * @template S
+ * @template T
+ * @typedef {(_: S) => (_: T) => S} Merge
+ */
+
+/** @type {<T, R>(merge: Merge<R, T>) => (init: R) => (_: Iterable<T>) => R} */
 const reduce = merge => init => c => {
     let result = init
     for (const i of c) {
@@ -10,8 +16,69 @@ const reduce = merge => init => c => {
     return result
 }
 
+/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
+const concat = a => b => ({
+    *[Symbol.iterator]() {
+        yield *a
+        yield *b
+    }
+})
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: Iterable<T>) => Iterable<A>} */
+const exclusiveScan = merge => init => c => ({
+    *[Symbol.iterator]() {
+        let result = init
+        for (const i of c) {
+            result = merge(result)(i)
+            yield result
+        }
+    }
+})
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: Iterable<T>) => Iterable<A>} */
+const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
+
+/** @type {<T, R>(es: mr.ExlusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const applyExclusiveScan = es => c => ({
+    *[Symbol.iterator]() {
+        let ies = es
+        for (const i of c) {
+            const result = ies(i)
+            ies = result[1]
+            yield result[0]
+        }
+    }
+})
+
+const entries = applyExclusiveScan(mr.entries)
+
 /** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: Iterable<I>) => R} */
-const apply = op => pipe(reduce(op.reduce)(op.init))(op.result)
+const apply = ({ merge, init, result }) => pipe(reduce(merge)(init))(result)
+
+const sum = apply(mr.sum)
+
+const size = apply(mr.size)
+
+const join = pipe(mr.join)(apply)
+
+/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
+const map = f => c => ({
+    *[Symbol.iterator]() {
+        for (const i of c) {
+            yield f(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 */
@@ -21,33 +88,26 @@ module.exports = {
     reduce,
 
     /** @readonly */
-    join: pipe(mr.join)(apply),
+    join,
 
     /** @readonly */
-    sum: apply(mr.sum),
+    sum,
 
-    /** 
-     * @readonly
-     * @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} 
-     */
-    map: f => c => ({
-        *[Symbol.iterator]() {
-            for (const i of c) {
-                yield f(i)
-            }
-        }
-    }),
+    /** @readonly */
+    size,
 
-    /** 
-     * @readonly
-     * @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} 
-     */
-    find: f => c => {
-        for (const i of c) {
-            if (f(i)) {
-                return i
-            }
-        }
-        return undefined
-    }
+    /** @readonly */
+    entries,
+
+    /** @readonly */
+    map,
+
+    /** @readonly */
+    exclusiveScan,
+
+    /** @readonly */
+    inclusiveScan,
+
+    /** @readonly */
+    find,
 }

package/iterable/test.js

@@ -38,4 +38,14 @@ const { pipe } = require('../func')
         (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/map-reduce/index.js

@@ -1,37 +1,72 @@
 const { pipe, id } = require('../func')
 
+/**
+ * @template S
+ * @template I
+ * @typedef {(state: S) => (value: I) => S} Merge
+ */
+
 /**
  * @template I
  * @template S
  * @template O
  * @typedef {{
- *  readonly reduce: (state: S) => (value: I) => S
+ *  readonly merge: Merge<S, I>
  *  readonly result: (state: S) => O
  *  readonly init: S
  * }} Operation
  */
 
 /** @type {<I, T>(mapFn: (value: I) => T) => <S, O>(op: Operation<T, S, O>) => Operation<I, S, O>} */
-const map = mapFn => ({ reduce, result, init}) => ({
-    reduce: pipe(reduce)(pipe(mapFn)),
+const map = mapFn => ({ merge, result, init}) => ({
+    merge: pipe(merge)(pipe(mapFn)),
     result,
     init,
 })
 
 /** @type {(separator: string) => Operation<string, string|undefined, string>} */
 const join = separator => ({ 
-    reduce: s => i => s === undefined ? i : `${s}${separator}${i}`, 
+    merge: s => i => s === undefined ? i : `${s}${separator}${i}`, 
     init: undefined,
     result: s => s === undefined ? '' : s
 })
 
 /** @type {Operation<number, number, number>} */
 const sum = { 
-    reduce: a => i => a + i, 
+    merge: a => i => a + i, 
     result: id,
     init: 0,
 }
 
+/**
+ * @type {{
+ *  readonly merge: (counter: number) => () => number
+ *  readonly result: (counter: number) => number
+ *  readonly init: number
+ * }}
+ */
+const size = {
+    merge: counter => () => counter + 1,
+    init: 0,
+    result: id,
+}
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => readonly [R, ExlusiveScan<T, R>]} ExlusiveScan
+ */
+
+/** 
+ * @template T
+ * @typedef {readonly[number, T]} Entry
+ */
+
+/** @type {(index: number) => <T>(value: T) => readonly[Entry<T>, ExlusiveScan<T, Entry<T>>]} */
+const entriesFrom = index => value => [[index, value], entriesFrom(index + 1)]
+
+const entries = entriesFrom(0)
+
 module.exports = {
     /** @readonly */
     map,
@@ -39,4 +74,8 @@ module.exports = {
     join,
     /** @readonly */
     sum,
+    /** @readonly */
+    size,
+    /** @readonly */
+    entries,
 }

package/module-manager/index.js

@@ -3,7 +3,6 @@ const { pipe } = require('../func')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
 const iter = require('../iterable')
-const mr = require('../map-reduce')
 
 /**
  * @template T
@@ -39,9 +38,9 @@ const mr = require('../map-reduce')
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {mr.Operation<string, undefined|Path, undefined|Path>} */
+/** @type {import('../map-reduce').Operation<string, undefined|Path, undefined|Path>} */
 const pathNormReduce = {
-    reduce: path => item =>
+    merge: path => item =>
         path === undefined ?
             undefined :
         ['', '.'].includes(item) ?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.161",
+  "version": "0.0.166",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -1,6 +1,7 @@
 const i = require('./')
 
-require('./async/test')
+require('./iterable/test')
+require('./async/iterable/test')
 require('./module-manager/test')
 
 /** @type {() => never} */

package/async/index.js

@@ -1,101 +0,0 @@
-const { pipe } = require('../func')
-
-/** @type {<T, R>(f: (value: T) => Promise<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
-const map = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield f(i)
-        }
-    }
-})
-
-/** @type {<T>(c: AsyncIterable<AsyncIterable<T>>) => AsyncIterable<T>} */
-const flatten = c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield *i
-        }
-    }
-})
-
-/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AsyncIterable<T>) => AsyncIterable<T>} */
-const filter = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            if (await f(i)) {
-                yield i
-            }
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => AsyncIterable<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => pipe(map(async x => f(x)))(flatten)
-
-/** 
- * @template A
- * @template T
- * @typedef {(accumulator: A) => (value: T) => Promise<A>} ReduceFn
- */
-
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
-const reduce = reduceFn => init => async c => {
-    let result = init
-    for await (const i of c) {
-        result = await reduceFn(result)(i)
-    }
-    return result
-}
-
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
-const exclusiveScan = reduceFn => init => c => ({
-    async *[Symbol.asyncIterator]() {
-        let result = init
-        for await (const i of c) {
-            result = await reduceFn(result)(i)
-            yield result
-        }
-    }
-})
-
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
-const inclusiveScan = reduceFn => init => {
-    const e = exclusiveScan(reduceFn)(init)
-    return c => ({
-        async *[Symbol.asyncIterator]() {
-            yield init
-            yield *e(c)
-        }
-    })
-}
-
-/** @type {<T>(iterable: Iterable<T>) => AsyncIterable<T>} */
-const cast = iterable => ({
-    async *[Symbol.asyncIterator]() {
-        for (const i of iterable) {
-            yield i
-        }
-    }
-})
-
-/** @type {(c: AsyncIterable<number>) => Promise<number>} */
-const sum = reduce(a => async v => a + v)(0)
-
-module.exports = {
-    /** @readonly */
-    cast,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    inclusiveScan,
-}