✨ MAP

Author: UltiRequiem

src/language/filter.test.ts

@@ -5,13 +5,25 @@ const data = [1, 2, 3, 4, 5];
 
 const cb = (item: number) => item % 2 === 0;
 
-Deno.test("[filter]", () => {
+Deno.test("[filter] Main", () => {
   const result = filter(data, cb);
 
   assertEquals(result, [2, 4]);
 });
 
-Deno.test("[filter vs Array.filter]", () => {
+Deno.test("[filter] Object", () => {
+  const example = [{ hey: true, value: "x" }, { hey: false }];
+
+  const cb = (item: typeof example[number]) => item.hey;
+
+  const result = filter(example, cb);
+  const expected = example.filter(cb);
+
+  assertEquals(result, [{ hey: true, value: "x" }]);
+  assertEquals(result, expected);
+});
+
+Deno.test("[filter] Versus Array.filter", () => {
   const expected = data.filter(cb);
   const result = filter(data, cb);
 

src/language/filter.ts

@@ -5,9 +5,11 @@ export type FilterCallback<T = never> = (
 ) => unknown;
 
 export function filter<T>(array: readonly T[], test: FilterCallback<T>) {
-  const result: T[] = [];
+  const result = [];
 
-  for (const [index, value] of array.entries()) {
+  const entries = array.entries();
+
+  for (const [index, value] of entries) {
     if (test(value, index, array)) {
       result.push(value);
     }

src/language/map.test.ts

@@ -0,0 +1,20 @@
+import { map } from "./map.ts";
+import { assert, assertEquals } from "../../deps.ts";
+
+const TEST_DATA = [1, 2, 3, 4, 5];
+
+Deno.test("[map] Versus Array.map", () => {
+  const result = map(TEST_DATA, (x) => x * 2);
+  const expected = TEST_DATA.map((x) => x * 2);
+
+  assertEquals(result, expected);
+});
+
+Deno.test("[map] Chaning Types", () => {
+  const result = map(TEST_DATA, (x) => `${x}`);
+  const expected = TEST_DATA.map((x) => `${x}`);
+
+  assert(result.every((x) => typeof x === "string"));
+
+  assertEquals(result, expected);
+});

src/language/map.ts

@@ -1,17 +1,17 @@
-export type MapCallback<T = never> = (
+export type MapCallback<T> = (
   value: T,
   index: number,
-  array: T[],
+  array: readonly T[],
 ) => unknown;
 
-export function map<T>(array: T[], transform: MapCallback<T>) {
-  const result: unknown[] = [];
+export function map<T, F extends MapCallback<T>>(array: T[], transform: F) {
+  const result = [];
 
-  for (const [index, value] of array.entries()) {
+  const entries = array.entries();
+
+  for (const [index, value] of entries) {
     result.push(transform(value, index, array));
   }
 
-  return result;
+  return result as ReturnType<F>[];
 }
-
-[].map;