✨ Stream機能追加

Author: hi2ma-bu4

dist/JavaLibraryScript.js

@@ -115,6 +115,7 @@ class TypeChecker extends JavaLibraryScriptCore {
 	static checkClass(fn) {
 		if (typeof fn !== "function") return false;
 		if (this._CLASS_REG.test(fn.toString())) return true;
+		if (fn === Function) return true;
 		try {
 			new new Proxy(fn, { construct: () => ({}) })();
 			return true;

dist/JavaLibraryScript.js.map

@@ -2,5 +2,6 @@ module.exports = {
   BaseMap: require("./BaseMap.js"),
   HashMap: require("./HashMap.js"),
   LinkedHashMap: require("./LinkedHashMap.js"),
-  TreeMap: require("./TreeMap.js")
+  TreeMap: require("./TreeMap.js"),
+  stream: require("./stream")
 };

dist/JavaLibraryScript.min.js

@@ -0,0 +1,172 @@
+const StreamInterface = require("./StreamInterface.js");
+const Stream = require("./Stream.js");
+
+class AsyncStream extends StreamInterface {
+	constructor(source) {
+		super();
+		this._iter = AsyncStream._normalize(source);
+		this._pipeline = [];
+	}
+
+	static from(iterable) {
+		return new AsyncStream(iterable);
+	}
+
+	static _normalize(input) {
+		if (typeof input[Symbol.asyncIterator] === "function") return input;
+		if (typeof input[Symbol.iterator] === "function") {
+			return (async function* () {
+				for (const x of input) yield x;
+			})();
+		}
+		throw new TypeError("not (Async)Iterable");
+	}
+
+	_use(fn) {
+		this._pipeline.push(fn);
+		return this;
+	}
+
+	// ==================================================
+	// パイプライン計算
+	// ==================================================
+
+	flattenPipeline() {
+		const flattenedFn = this._pipeline.reduceRight(
+			(nextFn, currentFn) => {
+				return async function* (iterable) {
+					yield* currentFn(nextFn(iterable));
+				};
+			},
+			async function* (x) {
+				yield* x;
+			}
+		);
+		const flat = new this.constructor([]);
+		flat._iter = this._iter;
+		flat._pipeline = [flattenedFn];
+		return flat;
+	}
+
+	toFunction() {
+		const flat = this.flattenPipeline();
+		const fn = flat._pipeline[0];
+		return (input) => fn(input);
+	}
+
+	// ==================================================
+	// Pipeline
+	// ==================================================
+
+	map(fn) {
+		return this._use(async function* (iter) {
+			for await (const x of iter) yield await fn(x);
+		});
+	}
+
+	filter(fn) {
+		return this._use(async function* (iter) {
+			for await (const x of iter) {
+				if (await fn(x)) yield x;
+			}
+		});
+	}
+
+	flatMap(fn) {
+		return this._use(async function* (iter) {
+			for await (const x of iter) {
+				const sub = await fn(x);
+				for await (const y of AsyncStream._normalize(sub)) yield y;
+			}
+		});
+	}
+
+	distinct(keyFn = (x) => x) {
+		return this._use(async function* (iter) {
+			const seen = new Set();
+			for await (const x of iter) {
+				const key = await keyFn(x);
+				if (!seen.has(key)) {
+					seen.add(key);
+					yield x;
+				}
+			}
+		});
+	}
+
+	limit(n) {
+		return this._use(async function* (iter) {
+			let i = 0;
+			for await (const x of iter) {
+				if (i++ < n) yield x;
+				else break;
+			}
+		});
+	}
+
+	skip(n) {
+		return this._use(async function* (iter) {
+			let i = 0;
+			for await (const x of iter) {
+				if (i++ >= n) yield x;
+			}
+		});
+	}
+
+	// ==================================================
+	// Iterator
+	// ==================================================
+
+	[Symbol.asyncIterator]() {
+		let iter = this._iter;
+		for (const op of this._pipeline) {
+			iter = op(iter);
+		}
+		return iter[Symbol.asyncIterator]();
+	}
+	// ==================================================
+	// End
+	// ==================================================
+
+	async forEach(fn) {
+		for await (const x of this) {
+			await fn(x);
+		}
+	}
+
+	async toArray() {
+		const result = [];
+		for await (const x of this) {
+			result.push(x);
+		}
+		return result;
+	}
+
+	async reduce(fn, init) {
+		let acc = init;
+		for await (const x of this) {
+			acc = await fn(acc, x);
+		}
+		return acc;
+	}
+
+	count() {
+		return this.reduce((acc) => acc + 1, 0);
+	}
+
+	// ==================================================
+	// mapTo
+	// ==================================================
+
+	toLazy() {
+		return new Promise(async (resolve) => {
+			const arr = [];
+			for await (const item of this) {
+				arr.push(item);
+			}
+			resolve(new Stream(arr));
+		});
+	}
+}
+
+module.exports = AsyncStream;

dist/JavaLibraryScript.min.js.map

@@ -0,0 +1,27 @@
+const Stream = require("./Stream.js");
+
+class EntryStream extends Stream {
+	constructor(source) {
+		super(source);
+
+		this.mapToEntry = undefined;
+	}
+
+	keys() {
+		return this._convertToX(Stream).map(([k, _]) => k);
+	}
+
+	values() {
+		return this._convertToX(Stream).map(([_, v]) => v);
+	}
+
+	mapKeys(fn) {
+		return this.map(([k, v]) => [fn(k), v]);
+	}
+
+	mapValues(fn) {
+		return this.map(([k, v]) => [k, fn(v)]);
+	}
+}
+
+module.exports = EntryStream;

src/libs/TypeChecker.js

@@ -0,0 +1,45 @@
+const Stream = require("./Stream.js");
+
+class NumberStream extends Stream {
+	constructor(source) {
+		super(source);
+
+		this.mapToNumber = undefined;
+	}
+
+	sum() {
+		let total = 0;
+		for (const num of this) {
+			total += num;
+		}
+		return total;
+	}
+
+	average() {
+		let total = 0;
+		let count = 0;
+		for (const num of this) {
+			total += num;
+			count++;
+		}
+		return count === 0 ? NaN : total / count;
+	}
+
+	min() {
+		let min = Infinity;
+		for (const num of this) {
+			if (num < min) min = num;
+		}
+		return min === Infinity ? undefined : min;
+	}
+
+	max() {
+		let max = -Infinity;
+		for (const num of this) {
+			if (num > max) max = num;
+		}
+		return max === -Infinity ? undefined : max;
+	}
+}
+
+module.exports = NumberStream;