feat(flatfold): implement a concatenating version of fold

It's like flatMap, but for folds.

Closes #4

src/fun-promise.test.js

@@ -737,4 +737,30 @@ describe("FunPromise", () => {
 			});
 		});
 	});
+
+	describe("flatFold", () => {
+		_.forEach([true, false], (staticVersion) => {
+			describe(staticVersion ? "static" : "instance", () => {
+				function doFlatFold(values, initialValues, accumulator) {
+					if (staticVersion) {
+						return FunPromise.flatFold(values, initialValues, accumulator);
+					} else {
+						return FunPromise.resolve(values).flatFold(
+							initialValues,
+							accumulator
+						);
+					}
+				}
+
+				it("basically works", async () => {
+					const values = [4, 5, 6];
+					const initialValues = [1, 2, 3];
+					const accumulator = (xs, x) => [x, x];
+					await expect(
+						doFlatFold(values, initialValues, accumulator)
+					).resolves.toEqual([1, 2, 3, 4, 4, 5, 5, 6, 6]);
+				});
+			});
+		});
+	});
 });

src/fun-promise.ts

@@ -419,9 +419,9 @@ export default class FunPromise<T> implements Promise<T> {
 		resolveValues: boolean = false,
 		sequentialResolution: boolean = false
 	): FunPromise<Item<T>[]> {
-		const aryPromise: FunPromise<Item<T>[]> = this.then((iter) => [
-			...((iter as unknown) as Iterable<Item<T>>),
-		]);
+		const aryPromise = (this.then(
+			async (iterPromise) => _toArray(await iterPromise) // Just to be sure we're all de-promise'd
+		) as unknown) as FunPromise<Item<T>[]>;
 		if (resolveValues) {
 			if (sequentialResolution) {
 				return aryPromise.then(async (ary) => {
@@ -698,6 +698,44 @@ export default class FunPromise<T> implements Promise<T> {
 		return FunPromise.resolve(values).fold(initialValue, accumulator);
 	}
 
+	/**
+	 * Given an initial array of values and an accumulator function, apply the accumlator function to each element of the promise's resolved value,
+	 * passing in the current array of values and the resolved item.  Returns an array with the concatenated results of the accumulation.
+	 * If any of the promise's values are rejected, the entire operation will be rejected.
+	 *
+	 * The resolution order is not guaranteed. The accumulator function will be passed values as those values resolve.
+	 */
+	flatFold<T2 = Item<T>>(
+		initialValue: PromisableIterable<T2>,
+		accumulator: (memo: T2[], it: Item<T>) => PromisableIterable<T2>
+	): FunPromise<T2[]> {
+		return this.arrayify().then(async (ary: Promisable<Item<T>>[]) => {
+			let memoPromise: FunPromise<T2[]> = FunPromise.resolve(
+				initialValue
+			).arrayify() as FunPromise<T2[]>;
+			await Promise.all(
+				_map(ary, async (promisableValue) => {
+					const value = await promisableValue;
+					memoPromise = memoPromise.then(async (memo) =>
+						memo.concat(_toArray(await accumulator(memo, value)))
+					);
+				})
+			);
+			return memoPromise;
+		});
+	}
+
+	/**
+	 * Equivalent to `FunPromise.resolve(values).flatFold(initialValue, accumulator)`.
+	 */
+	static flatFold<T, T2 = T>(
+		values: PromisableIterable<T>,
+		initialValue: PromisableIterable<T2>,
+		accumulator: (memo: T2[], it: T) => PromisableIterable<T2>
+	): FunPromise<T2[]> {
+		return FunPromise.resolve(values).flatFold(initialValue, accumulator);
+	}
+
 	/**
 	 * Handles rejections like 'catch', but wraps them in a [[`NestedError`]] with the given message.
 	 */