perf(collections): optimize minOf/maxOf with fast array paths (#6936)

Author: tomas-zijdemans

collections/max_of.ts

@@ -71,20 +71,43 @@ export function maxOf<T, S extends ((el: T) => number) | ((el: T) => bigint)>(
   array: Iterable<T>,
   selector: S,
 ): ReturnType<S> | undefined {
-  let maximumValue: ReturnType<S> | undefined;
+  if (Array.isArray(array)) {
+    const length = array.length;
+    if (length === 0) return undefined;
 
-  for (const element of array) {
-    const currentValue = selector(element) as ReturnType<S>;
+    let max = selector(array[0]!) as ReturnType<S>;
+    if (Number.isNaN(max)) return max;
 
-    if (maximumValue === undefined || currentValue > maximumValue) {
-      maximumValue = currentValue;
-      continue;
+    for (let i = 1; i < length; i++) {
+      const currentValue = selector(array[i]!) as ReturnType<S>;
+      if (currentValue > max) {
+        max = currentValue;
+      } else if (Number.isNaN(currentValue)) {
+        return currentValue;
+      }
     }
 
-    if (Number.isNaN(currentValue)) {
+    return max;
+  }
+
+  const iter = array[Symbol.iterator]();
+  const first = iter.next();
+
+  if (first.done) return undefined;
+
+  let max = selector(first.value) as ReturnType<S>;
+  if (Number.isNaN(max)) return max;
+
+  let next = iter.next();
+  while (!next.done) {
+    const currentValue = selector(next.value) as ReturnType<S>;
+    if (currentValue > max) {
+      max = currentValue;
+    } else if (Number.isNaN(currentValue)) {
       return currentValue;
     }
+    next = iter.next();
   }
 
-  return maximumValue;
+  return max;
 }

collections/max_of_test.ts

@@ -9,6 +9,11 @@ Deno.test("maxOf() handles regular max", () => {
   assertEquals(actual, 120);
 });
 
+Deno.test("maxOf() handles single element", () => {
+  const actual = maxOf([42], (i) => i);
+  assertEquals(actual, 42);
+});
+
 Deno.test("maxOf() handles mixed negatives and positives numbers", () => {
   const array = [-32, -18, 140, 36];
 
@@ -67,6 +72,36 @@ Deno.test("maxOf() handles no mutation", () => {
   assertEquals(array, [1, 2, 3, 4]);
 });
 
+Deno.test("maxOf() handles iterable input", () => {
+  function* generate() {
+    yield 5;
+    yield 2;
+    yield 8;
+    yield 1;
+  }
+
+  const actual = maxOf(generate(), (i) => i);
+  assertEquals(actual, 8);
+});
+
+Deno.test("maxOf() handles empty iterable", () => {
+  function* generate(): Generator<number> {}
+
+  const actual = maxOf(generate(), (i) => i);
+  assertEquals(actual, undefined);
+});
+
+Deno.test("maxOf() handles NaN in iterable", () => {
+  function* generate() {
+    yield 1;
+    yield NaN;
+    yield 3;
+  }
+
+  const actual = maxOf(generate(), (i) => i);
+  assertEquals(actual, NaN);
+});
+
 Deno.test("maxOf() handles empty array results in undefined", () => {
   const array: number[] = [];
 
@@ -93,6 +128,13 @@ Deno.test("maxOf() handles NaN and Infinity", () => {
   assertEquals(actual, NaN);
 });
 
+Deno.test("maxOf() handles NaN as first element", () => {
+  const array = [NaN, 1, 2, 3];
+
+  const actual = maxOf(array, (i) => i);
+  assertEquals(actual, NaN);
+});
+
 Deno.test("maxOf() handles infinity", () => {
   const array = [1, 2, Infinity, 3, 4, 5, 6, 7, 8];
 

collections/min_of.ts

@@ -71,20 +71,43 @@ export function minOf<T, S extends ((el: T) => number) | ((el: T) => bigint)>(
   array: Iterable<T>,
   selector: S,
 ): ReturnType<S> | undefined {
-  let minimumValue: ReturnType<S> | undefined;
+  if (Array.isArray(array)) {
+    const length = array.length;
+    if (length === 0) return undefined;
 
-  for (const element of array) {
-    const currentValue = selector(element) as ReturnType<S>;
+    let min = selector(array[0]!) as ReturnType<S>;
+    if (Number.isNaN(min)) return min;
 
-    if (minimumValue === undefined || currentValue < minimumValue) {
-      minimumValue = currentValue;
-      continue;
+    for (let i = 1; i < length; i++) {
+      const currentValue = selector(array[i]!) as ReturnType<S>;
+      if (currentValue < min) {
+        min = currentValue;
+      } else if (Number.isNaN(currentValue)) {
+        return currentValue;
+      }
     }
 
-    if (Number.isNaN(currentValue)) {
+    return min;
+  }
+
+  const iter = array[Symbol.iterator]();
+  const first = iter.next();
+
+  if (first.done) return undefined;
+
+  let min = selector(first.value) as ReturnType<S>;
+  if (Number.isNaN(min)) return min;
+
+  let next = iter.next();
+  while (!next.done) {
+    const currentValue = selector(next.value) as ReturnType<S>;
+    if (currentValue < min) {
+      min = currentValue;
+    } else if (Number.isNaN(currentValue)) {
       return currentValue;
     }
+    next = iter.next();
   }
 
-  return minimumValue;
+  return min;
 }

collections/min_of_test.ts

@@ -9,6 +9,11 @@ Deno.test("minOf() handles regular min", () => {
   assertEquals(actual, 5);
 });
 
+Deno.test("minOf() handles single element", () => {
+  const actual = minOf([42], (i) => i);
+  assertEquals(actual, 42);
+});
+
 Deno.test("minOf() handles mixed negatives and positives numbers", () => {
   const array = [-32, -18, 140, 36];
 
@@ -67,6 +72,36 @@ Deno.test("minOf() handles no mutation", () => {
   assertEquals(array, [1, 2, 3, 4]);
 });
 
+Deno.test("minOf() handles iterable input", () => {
+  function* generate() {
+    yield 5;
+    yield 2;
+    yield 8;
+    yield 1;
+  }
+
+  const actual = minOf(generate(), (i) => i);
+  assertEquals(actual, 1);
+});
+
+Deno.test("minOf() handles empty iterable", () => {
+  function* generate(): Generator<number> {}
+
+  const actual = minOf(generate(), (i) => i);
+  assertEquals(actual, undefined);
+});
+
+Deno.test("minOf() handles NaN in iterable", () => {
+  function* generate() {
+    yield 1;
+    yield NaN;
+    yield 3;
+  }
+
+  const actual = minOf(generate(), (i) => i);
+  assertEquals(actual, NaN);
+});
+
 Deno.test("minOf() handles empty array results in undefined", () => {
   const array: number[] = [];
 
@@ -93,6 +128,13 @@ Deno.test("minOf() handles NaN and Infinity", () => {
   assertEquals(actual, NaN);
 });
 
+Deno.test("minOf() handles NaN as first element", () => {
+  const array = [NaN, 1, 2, 3];
+
+  const actual = minOf(array, (i) => i);
+  assertEquals(actual, NaN);
+});
+
 Deno.test("minOf() handles minus infinity", () => {
   const array = [1, 2, -Infinity, 3, 4, 5, 6, 7, 8];