[API Proposal]: MemoryExtensions.Min/Max

[MizardX]

Background and motivation

I want to take the minimum or maximum of three or more DateTimeOffset.

Enumerable.Min/Max requires heap allocation. Math.Min/Max only takes two numeric arguments. INumber.Min/Max only implemented for numeric types.

I want to get find the minimum or maximum of a fixed set of values without extra heap allocation.

API Proposal

namespace System;

public partial static class MemoryExtensions
{
    public T? Min<T>(this ReadOnlySpan<T> span);
    public T? Min<T>(this ReadOnlySpan<T> span, IComparer<T> comparer);
    public T? Min<T, TComparer>(this ReadOnlySpan<T> span, TComparer comparer) where TComparer : IComparer<T>;

    public T? Max<T>(this ReadOnlySpan<T> span);
    public T? Max<T>(this ReadOnlySpan<T> span, IComparer<T> comparer);
    public T? Max<T, TComparer>(this ReadOnlySpan<T> span, TComparer comparer) where TComparer : IComparer<T>;
}

Similar to Enumerable.Min/Max, using Comparer<T>.Default as comparer if not specified.

API Usage

Span<DateTimeOffset> values = [
    DateTimeOffset.Parse("2026-03-14 16:18:04 +01:00"),
    DateTimeOffset.Parse("2026-04-16 00:50:35 +01:00"),
    DateTimeOffset.Parse("2026-03-23 18:13:43 +01:00")
];
Console.WriteLine($"Max: {values.Max()}");

Alternative Designs

Expand Math.Min/Max to both generic and variadic arguments.

namespace System;

public partial static class Math
{
    public T? Min<T>(params ReadOnlySpan<T> span);
    public T? Max<T>(params ReadOnlySpan<T> span);
}

Risks

It might cause ambiguity with Enumerable.Min/Max

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-memory
See info in area-owners.md if you want to be subscribed.

[ladeak]

You would probably also need an IComparer<T> parameter and or IComparable<T> generic constraint.

[tannergooding]

System.Math is soft deprecated and we aren't exposing new APIs on it, so the alternative design is a non-starter.

In addition, it would be confusing when placed next to the existing Max/Min APIs which are the arithmetical comparisons and not the IComparer based comparisons

Essentially you have:

• (TComparer.Compare(x, y) > 0) ? x
  • Follows the IComparer rules rules
  • Is suitable for use in sorting algorithms, hashsets, etc
• INumber<T>.Max(x, y)
  • Follows the arithmetic rules of the T
  • May not be suitable for sorting algorithms, hashsets, etc

Enumerable.Max exposes the former, defaulting to Comparer<T>.Default; while INumber<T>.Max defaults to the latter, which also means that TensorPrimitives.Max<T>(ReadOnlySpan<T>) where T : INumber<T> does as well

---

I'd think if we exposed support here, it'd need to match Enumerable behavior and then also generally match the overloads that we expose on other MemoryExtensions APIs:

namespace System;

public partial static class MemoryExtensions
{
    public T? Min<T>(ReadOnlySpan<T> span);
    public T? Min<T>(ReadOnlySpan<T> span, IComparer<T> comparer);
    public T? Min<T, TComparer>(ReadOnlySpan<T> span, TComparer comparer) where TComparer : IComparer<T>;

    public T? Max<T>(ReadOnlySpan<T> span);
    public T? Max<T>(ReadOnlySpan<T> span, IComparer<T> comparer);
    public T? Max<T, TComparer>(ReadOnlySpan<T> span, TComparer comparer) where TComparer : IComparer<T>;
}

We do not need the Span<T> overloads, particularly thanks to the First Class Spans feature.

[tannergooding]

I'd be fine taking this to API review if the proposal was updated to what I suggested, covering the 6 overloads.

[MizardX]

I agree. Updated.

[ladeak]

Would you need a generic constraint also for: public T? Min/Max<T>(ReadOnlySpan<T> span); ?

[MizardX]

I don't think so.

IComparable<T> would would probably require boxing the values, and Enumerable.Min/Max does not have any such constraints; It relies on Comparer<T>.Default.

[tannergooding]

Right, in general you can use EqualityComparer<T>.Default or Comparer<T>.Default instead of constraining yourself to be where T : IEquatable<T> or where T : IComparer<T>

We've often explicitly removed constraints to allow support for more types and because the pattern is well optimized by the JIT.

[jkotas]

public T? Min(ReadOnlySpan span);

Should this be public T? Min<T>(this ReadOnlySpan<T> span); so that it is actually an extension method?