functionalscript 0.0.166 → 0.0.167

package/async/iterable/index.js

@@ -1,5 +1,5 @@
-const { pipe } = require('../../func')
-const mr = require('../../map-reduce')
+const { pipe } = require('../../function')
+const seq = require('../../sequence')
 
 /** 
  * @template T
@@ -14,10 +14,10 @@ const mr = require('../../map-reduce')
 
 /**
  * @template T
- * @typedef {Iterable<T> | AsyncIterable<T>} AnyIterator
+ * @typedef {Iterable<T> | AsyncIterable<T>} AnyIterable
  */
 
-/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AnyIterator<T>) => AsyncIterable<R>} */
+/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
 const map = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -26,7 +26,7 @@ const map = f => c => ({
     }
 })
 
-/** @type {<T>(c: AnyIterator<AnyIterator<T>>) => AsyncIterable<T>} */
+/** @type {<T>(c: AnyIterable<AnyIterable<T>>) => AsyncIterable<T>} */
 const flatten = c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -35,7 +35,7 @@ const flatten = c => ({
     }
 })
 
-/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AnyIterator<T>) => AnyIterator<T>} */
+/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AnyIterable<T>) => AnyIterable<T>} */
 const filter = f => c => ({
     async *[Symbol.asyncIterator]() {
         for await (const i of c) {
@@ -46,7 +46,7 @@ const filter = f => c => ({
     }
 })
 
-/** @type {<T, R>(f: (value: T) => AnyIterator<R>) => (c: AnyIterator<T>) => AsyncIterable<R>} */
+/** @type {<T, R>(f: (value: T) => AnyIterable<R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
 const flatMap = f => pipe(map(f))(flatten)
 
 /** 
@@ -55,7 +55,7 @@ const flatMap = f => pipe(map(f))(flatten)
  * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
  */
 
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => Promise<A>} */
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => Promise<A>} */
 const reduce = merge => init => async c => {
     let result = init
     for await (const i of c) {
@@ -64,7 +64,7 @@ const reduce = merge => init => async c => {
     return result
 }
 
-/** @type {<T>(a: AnyIterator<T>) => (b: AnyIterator<T>) => AsyncIterable<T>} */
+/** @type {<T>(a: AnyIterable<T>) => (b: AnyIterable<T>) => AsyncIterable<T>} */
 const concat = a => b => ({
     async *[Symbol.asyncIterator]() {
         yield* a
@@ -72,7 +72,7 @@ const concat = a => b => ({
     }
 })
 
-/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => AsyncIterable<A>} */
+/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => AsyncIterable<A>} */
 const exclusiveScan = merge => init => c => ({
     async *[Symbol.asyncIterator]() {
         let result = init
@@ -83,17 +83,29 @@ const exclusiveScan = merge => init => c => ({
     }
 })
 
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterator<T>) => AsyncIterable<A>} */
+/** @type {<T, R>(es: seq.ExlusiveScan<T, R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
+const applyExclusiveScan = es => c => ({
+    async *[Symbol.asyncIterator]() {
+        let ies = es
+        for await (const i of c) {
+            const result = ies(i)
+            ies = result[1]
+            yield result[0]
+        }
+    }
+})
+
+/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterable<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>} */
+/** @type {<I, S, R>(op: seq.Operation<I, S, R>) => (_: AnyIterable<I>) => Promise<R>} */
 const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
 
-const sum = apply(mr.sum)
+const sum = apply(seq.sum)
 
-const join = pipe(mr.join)(apply)
+const join = pipe(seq.join)(apply)
 
-const size = apply(mr.size)
+const size = apply(seq.size)
 
 module.exports = {
     /** @readonly */

package/iterable/index.js

@@ -1,5 +1,5 @@
-const { pipe } = require('../func')
-const mr = require('../map-reduce')
+const { pipe } = require('../function')
+const seq = require('../sequence')
 
 /**
  * @template S
@@ -38,7 +38,7 @@ const exclusiveScan = merge => init => c => ({
 /** @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>} */
+/** @type {<T, R>(es: seq.ExlusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
 const applyExclusiveScan = es => c => ({
     *[Symbol.iterator]() {
         let ies = es
@@ -50,16 +50,16 @@ const applyExclusiveScan = es => c => ({
     }
 })
 
-const entries = applyExclusiveScan(mr.entries)
+const entries = applyExclusiveScan(seq.entries)
 
-/** @type {<I, S, R>(op: mr.Operation<I, S, R>) => (_: Iterable<I>) => R} */
+/** @type {<I, S, R>(op: seq.Operation<I, S, R>) => (_: Iterable<I>) => R} */
 const apply = ({ merge, init, result }) => pipe(reduce(merge)(init))(result)
 
-const sum = apply(mr.sum)
+const sum = apply(seq.sum)
 
-const size = apply(mr.size)
+const size = apply(seq.size)
 
-const join = pipe(mr.join)(apply)
+const join = pipe(seq.join)(apply)
 
 /** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
 const map = f => c => ({

package/iterable/test.js

@@ -1,5 +1,5 @@
 const i = require('.')
-const { pipe } = require('../func')
+const { pipe } = require('../function')
 
 {
     const r = i.sum([120, 300, 42])

package/module-manager/index.js

@@ -1,5 +1,5 @@
 const array = require('../array')
-const { pipe } = require('../func')
+const { pipe } = require('../function')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
 const iter = require('../iterable')
@@ -38,7 +38,7 @@ const iter = require('../iterable')
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {import('../map-reduce').Operation<string, undefined|Path, undefined|Path>} */
+/** @type {import('../sequence').Operation<string, undefined|Path, undefined|Path>} */
 const pathNormReduce = {
     merge: path => item =>
         path === undefined ?

package/package.json

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

package/{map-reduce → sequence}/index.js

@@ -1,4 +1,4 @@
-const { pipe, id } = require('../func')
+const { pipe, id } = require('../function')
 
 /**
  * @template S
@@ -57,6 +57,16 @@ const size = {
  * @typedef {(value: T) => readonly [R, ExlusiveScan<T, R>]} ExlusiveScan
  */
 
+/**
+ * @template T
+ * @template R
+ * @template I
+ * @typedef {{
+ *  readonly exlusive: ExlusiveScan<T, R>
+ *  readonly default: I
+ * }} InclusiveScan
+ */
+
 /** 
  * @template T
  * @typedef {readonly[number, T]} Entry