diff --git a/deno.json b/deno.json
index be2ddad..fbe660f 100644
--- a/deno.json
+++ b/deno.json
@@ -1,6 +1,6 @@
 {
   "name": "@tyler/duckhawk",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "native Promise based implementations of bluebird utilities",
   "exports": "./src/index.ts",
   "repository": {
diff --git a/src/map-series.ts b/src/map-series.ts
index fec2d7b..8d4d9d1 100644
--- a/src/map-series.ts
+++ b/src/map-series.ts
@@ -1,10 +1,8 @@
-// deno-lint-ignore-file no-explicit-any
-
 /**
  * run Promises all in series
  *
- * @param arr list of promises
- * @param iterator map callback for each promise result
+ * @param arr list of items
+ * @param iterator map callback for creating a promise for each item
  * @returns result of iterator for each promise
  *
  * @example
@@ -18,12 +16,9 @@
  * console.log(result); // [2, 3, 4]
  * ```
  */
-export const mapSeries = async <
-  PromiseGiven extends Promise<any>,
-  IteratorResult
->(
-  arr: PromiseGiven[],
-  iterator: (item: Awaited<PromiseGiven>, index: number) => IteratorResult
+export const mapSeries = async <Item, IteratorResult>(
+  arr: Item[],
+  iterator: (item: Item, index: number) => Promise<IteratorResult>
 ): Promise<IteratorResult[]> => {
   const results: IteratorResult[] = [];
   for (let i = 0; i < arr.length; i++) {
diff --git a/src/map.ts b/src/map.ts
index 198ec4f..b6d53c7 100644
--- a/src/map.ts
+++ b/src/map.ts
@@ -1,27 +1,25 @@
-// deno-lint-ignore-file no-explicit-any
-
 /**
  * run Promises all in parallel and pass result to iterator
  *
- * @param arr list of promises
- * @param iterator map callback for each promise result
+ * @param arr list of items
+ * @param iterator map callback to create a promise for each item
  * @param options concurrency to limit number of promises to run in parallel
  * @returns result of iterator for each promise
  *
  * @example
  * ```ts
  * const result = await duckhawk.map(
- *   [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
- *   (item) => item + 1,
+ *   [1, 2, 3],
+ *   (item) => Promise.resolve(item + 1),
  *   { concurrency: 2 }
  * );
  *
  * console.log(result); // [2, 3, 4]
  * ```
  */
-export const map = async <PromiseGiven extends Promise<any>, IteratorResult>(
-  arr: PromiseGiven[],
-  iterator: (item: Awaited<PromiseGiven>, index: number) => IteratorResult,
+export const map = async <Item, IteratorResult>(
+  arr: Item[],
+  iterator: (item: Item, index: number) => Promise<IteratorResult>,
   options?: {
     concurrency?: number;
   }
diff --git a/src/reduce.ts b/src/reduce.ts
index 94f1dcd..5c49b63 100644
--- a/src/reduce.ts
+++ b/src/reduce.ts
@@ -1,10 +1,7 @@
-// deno-lint-ignore-file no-explicit-any
-
-// TODO read docs and add tests
 /**
  * reduce implementation with async/await.
  *
- * @param arr list of promises
+ * @param arr list of items to create a promise for
  * @param iterator reduce callback for each promise result
  * @param initialValue initial value for reduce
  * @returns result of iterator for each promise
@@ -20,13 +17,13 @@
  * console.log(result); // 6
  * ```
  */
-export const reduce = async <PromiseGiven extends Promise<any>, InitialValue>(
-  arr: PromiseGiven[],
+export const reduce = async <Item, InitialValue>(
+  arr: Item[],
   iterator: (
     acc: InitialValue,
-    item: Awaited<PromiseGiven>,
+    item: Item,
     index: number
-  ) => InitialValue,
+  ) => Promise<InitialValue>,
   initialValue: InitialValue
 ): Promise<InitialValue> => {
   let result = initialValue;
diff --git a/src/test/map-series.test.ts b/src/test/map-series.test.ts
index 7d4ab78..a54e670 100644
--- a/src/test/map-series.test.ts
+++ b/src/test/map-series.test.ts
@@ -2,45 +2,26 @@ import { mapSeries } from "../map-series.ts";
 import { expect } from "@std/expect";
 
 Deno.test("mapSeries simple", async () => {
-  const result = await mapSeries(
-    [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
-    (item) => item + 1
-  );
-  expect(result).toEqual([2, 3, 4]);
-});
-
-Deno.test("mapSeries with async", async () => {
-  const result = await mapSeries(
-    [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
-    async (item) => item + (await Promise.resolve(1))
+  const result = await mapSeries([1, 2, 3], (item) =>
+    Promise.resolve(item + 1)
   );
   expect(result).toEqual([2, 3, 4]);
 });
 
 Deno.test("mapSeries with mixed types", async () => {
-  const result = await mapSeries(
-    [
-      Promise.resolve(1),
-      Promise.resolve("hi"),
-      Promise.resolve({ foo: "bar" }),
-    ],
-    (item) => (typeof item === "object" ? item : item + "!")
+  const result = await mapSeries([1, "hi", { foo: "bar" }], (item) =>
+    Promise.resolve(typeof item === "object" ? item : item + "!")
   );
   expect(result).toEqual(["1!", "hi!", { foo: "bar" }]);
 });
 
 Deno.test("mapSeries executes in order", async () => {
   const order: number[] = [];
-  const result = await mapSeries(
-    [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
-    (item, ind) => {
-      order.push(item);
-      expect(order).toEqual(
-        Array.from({ length: ind + 1 }).map((_, i) => i + 1)
-      );
-      return item;
-    }
-  );
+  const result = await mapSeries([1, 2, 3], (item, ind) => {
+    order.push(item);
+    expect(order).toEqual(Array.from({ length: ind + 1 }).map((_, i) => i + 1));
+    return Promise.resolve(item);
+  });
 
   expect(result).toEqual([1, 2, 3]);
 });
diff --git a/src/test/map.test.ts b/src/test/map.test.ts
index d966247..6d1016b 100644
--- a/src/test/map.test.ts
+++ b/src/test/map.test.ts
@@ -2,29 +2,13 @@ import { map } from "../map.ts";
 import { expect } from "@std/expect";
 
 Deno.test("map simple", async () => {
-  const result = await map(
-    [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
-    (item) => item + 1
-  );
-  expect(result).toEqual([2, 3, 4]);
-});
-
-Deno.test("map with async", async () => {
-  const result = await map(
-    [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
-    async (item) => item + (await Promise.resolve(1))
-  );
+  const result = await map([1, 2, 3], (item) => Promise.resolve(item + 1));
   expect(result).toEqual([2, 3, 4]);
 });
 
 Deno.test("map with mixed types", async () => {
-  const result = await map(
-    [
-      Promise.resolve(1),
-      Promise.resolve("hi"),
-      Promise.resolve({ foo: "bar" }),
-    ],
-    (item) => (typeof item === "object" ? item : item + "!")
+  const result = await map([1, "hi", { foo: "bar" }], (item) =>
+    Promise.resolve(typeof item === "object" ? item : item + "!")
   );
   expect(result).toEqual(["1!", "hi!", { foo: "bar" }]);
 });
@@ -34,13 +18,13 @@ Deno.test("map concurrency", async () => {
     const order: number[] = [];
 
     const result = await map(
-      Array.from({ length: 10 * i }).map((_, i) => Promise.resolve(i + 1)),
+      Array.from({ length: 10 * i }).map((_, i) => i + 1),
       (item, ind) => {
         order.push(item);
         expect(order).toEqual(
           Array.from({ length: ind + 1 }).map((_, i) => i + 1)
         );
-        return item;
+        return Promise.resolve(item);
       },
       { concurrency: Math.random() * 10 }
     );
diff --git a/src/test/reduce.test.ts b/src/test/reduce.test.ts
index c3ab05b..394be52 100644
--- a/src/test/reduce.test.ts
+++ b/src/test/reduce.test.ts
@@ -3,8 +3,8 @@ import { expect } from "@std/expect";
 
 Deno.test("reduce simple", async () => {
   const result = await reduce(
-    [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
-    (acc, item) => acc + item,
+    [1, 2, 3],
+    (acc, item) => Promise.resolve(acc + item),
     0
   );
   expect(result).toEqual(6);
@@ -13,8 +13,13 @@ Deno.test("reduce simple", async () => {
 Deno.test("reduce error", async () => {
   await expect(
     reduce(
-      [Promise.resolve(1), Promise.reject(new Error("fail"))],
-      (acc, item) => acc + item,
+      [1, new Error("fail")],
+      (acc, item) => {
+        if (item instanceof Error) {
+          throw item;
+        }
+        return Promise.resolve(acc + item);
+      },
       0
     )
   ).rejects.toThrow("fail");