feat: change reduce behavior, when empty iterable

src/every.ts

@@ -58,7 +58,12 @@ function every<
     return pipe(
       map(f, iterable),
       takeUntil(not),
-      reduce((a, b) => a && b),
+      (acc) =>
+        reduce(
+          (a: boolean, b: boolean) => a && b,
+          true,
+          acc as Iterable<boolean>,
+        ),
       (a) => a ?? true,
       Boolean,
     );
@@ -68,7 +73,12 @@ function every<
     return pipe(
       map(f, iterable),
       takeUntil(not),
-      reduce((a, b) => a && b),
+      (acc) =>
+        reduce(
+          (a: boolean, b: boolean) => a && b,
+          true,
+          acc as AsyncIterable<boolean>,
+        ),
       (a) => a ?? true,
       Boolean,
     );

src/join.ts

@@ -10,7 +10,11 @@ type ReturnJoinType<T extends Iterable<unknown> | AsyncIterable<unknown>> =
     : never;
 
 function sync<A>(sep: string, iterable: Iterable<A>) {
-  const res = reduce((a: string, b) => `${a}${sep}${b}`, iterable);
+  const res = reduce(
+    (a: string, b) => (a == "" ? `${b}` : `${a}${sep}${b}`),
+    "",
+    iterable,
+  );
   if (res == null) {
     return "";
   }
@@ -19,7 +23,11 @@ function sync<A>(sep: string, iterable: Iterable<A>) {
 }
 
 function async<A>(sep: string, iterable: AsyncIterable<A>) {
-  return reduce((a: string, b) => `${a}${sep}${b}`, iterable).then((res) => {
+  return reduce(
+    (a: string, b) => (a == "" ? `${b}` : `${a}${sep}${b}`),
+    "",
+    iterable,
+  ).then((res) => {
     if (res == null) {
       return "";
     }

src/reduce.ts

@@ -72,8 +72,6 @@ async function async<A, B>(
  * {@link https://fxts.dev/docs/map | map}, {@link https://fxts.dev/docs/filter | filter}
  */
 
-function reduce<A extends readonly []>(f: Arrow, iterable: A): undefined;
-
 function reduce<A extends readonly [], B>(f: Arrow, seed: B, iterable: A): B;
 
 function reduce<A>(f: (a: A, b: A) => A, iterable: Iterable<A>): A;
@@ -113,11 +111,7 @@ function reduce<A extends Iterable<unknown> | AsyncIterable<unknown>, B>(
   f: (a: B, b: IterableInfer<A>) => B,
   seed?: B | Iterable<IterableInfer<A>> | AsyncIterable<IterableInfer<A>>,
   iterable?: Iterable<IterableInfer<A>> | AsyncIterable<IterableInfer<A>>,
-):
-  | B
-  | undefined
-  | Promise<B | undefined>
-  | ((iterable: A) => ReturnValueType<A, B>) {
+): B | Promise<B> | ((iterable: A) => ReturnValueType<A, B>) {
   if (iterable === undefined) {
     if (seed === undefined) {
       return (iterable: A) =>
@@ -128,7 +122,7 @@ function reduce<A extends Iterable<unknown> | AsyncIterable<unknown>, B>(
       const iterator = seed[Symbol.iterator]();
       const { done, value } = iterator.next();
       if (done) {
-        return undefined;
+        throw new TypeError("'reduce' of empty iterable with no initial value");
       }
       return sync(f, value as B, {
         [Symbol.iterator]() {
@@ -141,8 +135,11 @@ function reduce<A extends Iterable<unknown> | AsyncIterable<unknown>, B>(
       const iterator = seed[Symbol.asyncIterator]();
       return iterator.next().then(({ done, value }) => {
         if (done) {
-          return undefined;
+          throw new TypeError(
+            "'reduce' of empty iterable with no initial value",
+          );
         }
+
         return async(f, value as Promise<B>, {
           [Symbol.asyncIterator]() {
             return iterator;

src/some.ts

@@ -78,7 +78,12 @@ function some<
     return pipe(
       map(f, iterable),
       takeUntil(identity),
-      reduce((a, b) => a || b),
+      (acc) =>
+        reduce(
+          (a: boolean, b: boolean) => a || b,
+          false,
+          acc as Iterable<boolean>,
+        ),
       Boolean,
     );
   }
@@ -87,7 +92,12 @@ function some<
     return pipe(
       map(f, iterable),
       takeUntil(identity),
-      reduce((a, b) => a || b),
+      (acc) =>
+        reduce(
+          (a: boolean, b: boolean) => a || b,
+          false,
+          acc as AsyncIterable<boolean>,
+        ),
       Boolean,
     );
   }

test/reduce.spec.ts

@@ -9,8 +9,8 @@ describe("reduce", function () {
       expect(reduce((a, b) => a + b, "seed", [])).toEqual("seed");
     });
 
-    it("should return 'undefined' when the given `iterable` is an empty array and initial value is absent", function () {
-      expect(reduce((a, b) => a + b, [])).toBeUndefined();
+    it("should be occured error when the given `iterable` is an empty array and initial value is absent", function () {
+      expect(() => reduce((a) => a, [])).toThrow();
     });
 
     it("should work given it is initial value", function () {

type-check/reduce.test.ts

@@ -3,7 +3,7 @@ import * as Test from "../src/types/Test";
 
 const { checks, check } = Test;
 
-const res1 = reduce((a, b) => a + b, []);
+const res1 = reduce((a) => a, []);
 const res2 = reduce((a, b) => a + b, "seed", []);
 const res3 = reduce((a, b) => a + b, 0, [1, 2, 3]);
 const res4 = reduce((a, b) => a + b, [1, 2, 3]);
@@ -52,7 +52,7 @@ const res16 = pipe(
 );
 
 checks([
-  check<typeof res1, undefined, Test.Pass>(),
+  check<typeof res1, never, Test.Pass>(),
   check<typeof res2, "seed", Test.Pass>(),
   check<typeof res3, number, Test.Pass>(),
   check<typeof res4, number, Test.Pass>(),