feat(list): Generic implementation of Max and Min functions. (#186)

BREAKING CHANGE: Min() and Max() functions are now generic.

Author: mobilebilly

__tests__/list.test.ts

@@ -569,14 +569,72 @@ test('Max', t => {
   ])
   t.is(
     people.Max(x => x.Age ?? 0),
-    50
+    people.Last()
   )
   t.is(
     new List<number>([1, 2, 3, 4, 5]).Max(),
     5
   )
 })
 
+test('Max_undefinedComparer', t => {
+  const people = new List<IPerson>([
+    { Age: 15, Name: 'Cathy' },
+    { Age: 25, Name: 'Alice' },
+    { Age: 50, Name: 'Bob' }
+  ])
+
+  t.throws(() => people.Max(), {
+    message: /InvalidOperationException: No comparer available./
+  })
+})
+
+test('Max_emptyElements', t => {
+  const people = new List<IPerson>([])
+
+  t.is(
+    people.Max(),
+    undefined
+  )
+})
+
+test('Max_number', t => {
+  const nums = new List<number>([
+    10,
+    5,
+    -5
+  ])
+  t.is(
+    nums.Max(),
+    10
+  )
+})
+
+test('Max_string', t => {
+  const people = new List<string>([
+    'Cathy',
+    'Alice',
+    'Bob'
+  ])
+  t.is(
+    people.Max(),
+    'Cathy'
+  )
+})
+
+test('Max_boolean', t => {
+  const bools = new List<boolean>([
+    true,
+    false,
+    true,
+    false
+  ])
+  t.is(
+    bools.Max(),
+    true
+  )
+})
+
 test('Min', t => {
   const people = new List<IPerson>([
     { Age: 15, Name: 'Cathy' },
@@ -585,14 +643,74 @@ test('Min', t => {
   ])
   t.is(
     people.Min(x => x.Age ?? 0),
-    15
+    people.First()
   )
   t.is(
     new List<number>([1, 2, 3, 4, 5]).Min(),
     1
   )
 })
 
+
+test('Min_undefinedComparer', t => {
+  const people = new List<IPerson>([
+    { Age: 15, Name: 'Cathy' },
+    { Age: 25, Name: 'Alice' },
+    { Age: 50, Name: 'Bob' }
+  ])
+
+  t.throws(() => people.Min(), {
+    message: /InvalidOperationException: No comparer available./
+  })
+})
+
+test('Min_emptyElements', t => {
+  const people = new List<IPerson>([])
+
+  t.is(
+    people.Min(),
+    undefined
+  )
+})
+
+test('Min_number', t => {
+  const nums = new List<number>([
+    10,
+    5,
+    -5
+  ])
+  t.is(
+    nums.Min(),
+    -5
+  )
+})
+
+test('Min_string', t => {
+  const people = new List<string>([
+    'Cathy',
+    'Alice',
+    'Bob'
+  ])
+  t.is(
+    people.Min(),
+    'Alice'
+  )
+})
+
+test('Min_boolean', t => {
+  const bools = new List<boolean>([
+    true,
+    false,
+    true,
+    false
+  ])
+  t.is(
+    bools.Min(),
+    false
+  )
+})
+
+
 test('OfType', t => {
   const pets = new List<Pet>([
     new Dog({ Age: 8, Name: 'Barley', Vaccinated: true }),
@@ -1059,12 +1177,12 @@ test('ToDictionary', t => {
   // t.is(dictionary2['Alice'], 25)
   // Dictionary should behave just like in C#
   t.is(
-    dictionary.Max(x => x?.Value?.Age ?? 0),
-    50
+    dictionary.Max(x => x?.Value?.Age ?? 0)?.Value,
+    people.Last()
   )
   t.is(
-    dictionary.Min(x => x?.Value?.Age ?? 0),
-    15
+    dictionary.Min(x => x?.Value?.Age ?? 0)?.Value,
+    people.First()
   )
   const expectedKeys = new List(['Cathy', 'Alice', 'Bob'])
   t.deepEqual(

src/list.ts

@@ -309,20 +309,67 @@ class List<T> {
     return this.Count() ? this.Last() : defaultValue
   }
 
+  // A map of built-in primitive type names to their default comparison functions.
+  // This supports number, string, and boolean only
+  private static readonly comparers = new Map<string, Function>([
+    ['number', (a: number, b: number) => a - b],
+    ['string', (a: string, b: string) => a.localeCompare(b)],
+    ['boolean', (a: boolean, b: boolean) => Number(a) - Number(b)]
+  ]);
+
+  /**
+ * Retrieves a default comparer function based on the type of the provided sample value.
+ * Only supports primitive types: number, string, and boolean.
+ * 
+ * @param sample - A sample value used to determine its type.
+ * @returns A comparison function suitable for the type of the sample, or undefined if unsupported.
+ */
+  private static getComparer<T>(sample: T): ((a: T, b: T) => number) | undefined {
+    const type = typeof sample;
+    return List.comparers.get(type) as (a: T, b: T) => number;
+  }
+
   /**
    * Returns the maximum value in a generic sequence.
    */
-  public Max(selector?: (element: T, index: number) => number): number {
-    const identity = (x: T): number => x as number
-    return Math.max(...this.Select(selector || identity).ToList())
+  public Max(comparer?: (element: T) => number): T | undefined {
+    if (this._elements.length === 0) return undefined;
+
+    let maxElem = this._elements[0];
+    let comparerToUse = comparer || List.getComparer<T>(maxElem);
+
+    if (!comparerToUse) {
+      throw new Error('InvalidOperationException: No comparer available.')
+    }
+
+    this._elements.forEach(elem => {
+      if (comparerToUse(elem, maxElem) > 0) {
+        maxElem = elem;
+      }
+    })
+
+    return maxElem;
   }
 
   /**
    * Returns the minimum value in a generic sequence.
    */
-  public Min(selector?: (element: T, index: number) => number): number {
-    const identity = (x: T): number => x as number
-    return Math.min(...this.Select(selector || identity).ToList())
+  public Min(comparer?: (element: T) => number): T | undefined {
+    if (this._elements.length === 0) return undefined;
+
+    let minElem = this._elements[0];
+    let comparerToUse = comparer || List.getComparer<T>(minElem);
+
+    if (!comparerToUse) {
+      throw new Error('InvalidOperationException: No comparer available.')
+    }
+
+    this._elements.forEach(elem => {
+      if (comparerToUse(elem, minElem) < 0) {
+        minElem = elem;
+      }
+    })
+    return minElem;
   }
 
   /**