functionalscript 0.0.161 → 0.0.162

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

@@ -1,6 +1,13 @@
-const { pipe } = require('../func')
+const { todo } = require('../../dev')
+const { pipe } = require('../../func')
+const mapReduce = require('../../map-reduce')
 
-/** @type {<T, R>(f: (value: T) => Promise<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
+/** 
+ * @template T
+ * @typedef {Promise<T>|T} PromiseOrValue
+ */
+
+/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
 const map = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -30,24 +37,24 @@ const filter = f => c => ({
 })
 
 /** @type {<T, R>(f: (value: T) => AsyncIterable<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => pipe(map(async x => f(x)))(flatten)
+const flatMap = f => pipe(map(f))(flatten)
 
 /** 
  * @template A
  * @template T
- * @typedef {(accumulator: A) => (value: T) => Promise<A>} ReduceFn
+ * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
  */
 
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
-const reduce = reduceFn => init => async c => {
+/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => Promise<A>} */
+const reduce = merge => init => async c => {
     let result = init
     for await (const i of c) {
-        result = await reduceFn(result)(i)
+        result = await merge(result)(i)
     }
     return result
 }
 
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
 const exclusiveScan = reduceFn => init => c => ({
     async *[Symbol.asyncIterator]() {
         let result = init
@@ -58,7 +65,7 @@ const exclusiveScan = reduceFn => init => c => ({
     }
 })
 
-/** @type {<A, T>(f: ReduceFn<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
+/** @type {<A, T>(f: Merge<A, T>) => (init: A) => (c: AsyncIterable<T>) => AsyncIterable<A>} */
 const inclusiveScan = reduceFn => init => {
     const e = exclusiveScan(reduceFn)(init)
     return c => ({
@@ -78,10 +85,14 @@ const cast = iterable => ({
     }
 })
 
-/** @type {(c: AsyncIterable<number>) => Promise<number>} */
-const sum = reduce(a => async v => a + v)(0)
+/** @type {<I, S, R>(op: mapReduce.Operation<I, S, R>) => (_: AsyncIterable<I>) => Promise<R>} */
+const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
+
+const sum = apply(mapReduce.sum)
 
 module.exports = {
+    /** @readonly */
+    apply,
     /** @readonly */
     cast,
     /** @readonly */

package/iterable/index.js

@@ -11,7 +11,7 @@ const reduce = merge => init => c => {
 }
 
 /** @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)
 
 module.exports = {
     /** @readonly */

package/map-reduce/index.js

@@ -1,33 +1,39 @@
 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,
 }

package/module-manager/index.js

@@ -41,7 +41,7 @@ const mr = require('../map-reduce')
 
 /** @type {mr.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.162",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {

package/test.js

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