Add join/asyncJoin functions

README.md

@@ -175,6 +175,13 @@ console.log(result);
 * **asyncCollectObject**: (iterator: AsyncIterable) => Promise<Object>;
 
     Same as `collectObject`, but works with promises.
+* **join**: (separator: string, iterator: Iterable) => string;
+
+    Collect all the items in the iterator into a string separated by the
+    separator token.
+* **asyncJoin**: (separator: string, iterator: AsyncIterable) => Promise<string>;
+
+    Same as `join`, but works with promises.
 * **pipe**: (iterator: Iterable | AsyncIterable, ...fns: Function) => any;
 
     Starting with an iterator, apply any number of functions to transform the

lib/async.js

@@ -19,5 +19,6 @@ export {
   asyncCollectSet as collectSet,
   asyncCollectMap as collectMap,
   asyncCollectObject as collectObject,
+  asyncJoin as join,
   pipe
 } from "./index.js";

lib/collectors.spec.ts

@@ -3,7 +3,9 @@ import {
   collectArray, asyncCollectArray,
   collectSet, asyncCollectSet,
   collectMap, asyncCollectMap,
-  collectObject, asyncCollectObject
+  collectObject, asyncCollectObject,
+  join, asyncJoin,
+  empty
 } from "./index.js";
 
 
@@ -142,3 +144,57 @@ describe("asyncCollectObject", () => {
     expect(result).to.eql({ "foo": 1, "bar": 2, "baz": 3 });
   });
 });
+
+describe("join", () => {
+  it("empty", () => {
+    const result = join(",", empty());
+    expect(result).to.equal("");
+  });
+
+  it("one item", () => {
+    const subject = (function* () {
+      yield "foo";
+    }());
+
+    const result = join(",", subject);
+    expect(result).to.equal("foo");
+  });
+
+  it("multiple items", () => {
+    const subject = (function* () {
+      yield "foo";
+      yield "bar";
+      yield "baz";
+    }());
+
+    const result = join(",", subject);
+    expect(result).to.equal("foo,bar,baz");
+  });
+});
+
+describe("asyncJoin", () => {
+  it("empty", async () => {
+    const result = await asyncJoin(",", empty());
+    expect(result).to.equal("");
+  });
+
+  it("one item", async () => {
+    const subject = (async function* () {
+      yield "foo";
+    }());
+
+    const result = await asyncJoin(",", subject);
+    expect(result).to.equal("foo");
+  });
+
+  it("multiple items", async () => {
+    const subject = (async function* () {
+      yield "foo";
+      yield "bar";
+      yield "baz";
+    }());
+
+    const result = await asyncJoin(",", subject);
+    expect(result).to.equal("foo,bar,baz");
+  });
+});

lib/generators.spec.ts

@@ -531,12 +531,6 @@ describe("empty", () => {
   });
 });
 
-describe("empty", () => {
-  it("should be empty", () => {
-    expect([...empty()]).to.equal([]);
-  });
-});
-
 describe("zip", () => {
   it("same number of items", () => {
     const iter1 = (function* () {

lib/index.d.ts

@@ -148,5 +148,17 @@ export const asyncCollectMap: <A, B>(iterator: AsyncIterable<[A, B]>) => Promise
 export const collectObject: <A>(iterator: Iterable<[string, A]>) => Record<string, A>;
 export const asyncCollectObject: <A>(iterator: AsyncIterable<[string, A]>) => Promise<Record<string, A>>;
 
+export const join: (
+  (separator: string, iterator: Iterable<string>) => string
+) & (
+  (separator: string) => (iterator: Iterable<string>) => string
+);
+
+export const asyncJoin: (
+  (separator: string, iterator: Iterable<string> | AsyncIterable<string>) => Promise<string>
+) & (
+  (separator: string) => (iterator: Iterable<string> | AsyncIterable<string>) => Promise<string>
+);
+
 // eslint-disable-next-line @typescript-eslint/ban-types, @typescript-eslint/no-explicit-any
 export const pipe: <A>(iterator: Iterable<any> | AsyncIterable<any>, ...fns: Function[]) => A;

lib/index.js

@@ -283,6 +283,26 @@ export const asyncCollectObject = async (iter) => {
   return result;
 };
 
+export const join = curry((separator, iter) => {
+  let result = head(iter) || "";
+
+  for (const n of iter) {
+    result += separator + n;
+  }
+
+  return result;
+});
+
+export const asyncJoin = curry(async (separator, iter) => {
+  let result = await asyncHead(iter) || "";
+
+  for await (const n of iter) {
+    result += separator + n;
+  }
+
+  return result;
+});
+
 const getIterator = (iter) => {
   if (typeof iter?.[Symbol.iterator] === "function") {
     return iter[Symbol.iterator]();