Proposal: Enumerable.All() overloads for binary aggregation across a sequence

[ActivistInvestor]

I have in many cases, needed to determine if a given sequence of items is ordered (ascending/descending), for not only testing purposes, but also for optimization purposes. While test frameworks include this functionality, it can be also be useful in runtime scenarios.

I've been using my own simple overload of Enumerable.All() for this purpose,.

It is essentially a conditional take on Enumerable.Aggregate(), that receives a sequence of items and a binary function that returns a bool. The binary function is applied to successive adjacent elements until it returns false. Hence, it can be used to determined if a sequence is ordered using a simple function that uses the > or >= operators to compare the arguments (or by using IComparable).

The following code should be self-explanatory. The issue I've wrangled with in taking a more-generic approach, is the behavior when less than 2 elements appear in the sequence. Insofar as determining if a sequence is ordered (ascending/descending), any sequence containing fewer than 2 elements is considered to be ordered (in any way).

/// <summary>
/// Aggregates a function taking two instances of T
/// as arguments and returns a bool, across a sequence 
/// of T, and returns true if all invocations return 
/// true, or false otherwise.
/// 
/// If the sequence contains less than two elements, 
/// the result is true.
/// 
/// Evaluation of the function stops at the first 
/// result of false.
/// </summary>

public static bool All<T>(this IEnumerable<T> values, Func<T, T, bool> comparer)
{
   if(values == null)
      throw new ArgumentNullException(nameof(values));
   if(comparer == null)
      throw new ArgumentNullException(nameof(comparer));
   using(IEnumerator<T> e = values.GetEnumerator())
   {
      if(e.MoveNext())
      {
         T last = e.Current;
         while(e.MoveNext())
         {
            T next = e.Current;
            if(!comparer(last, next))
               return false;
            last = next;
         }
      }
      return true;
   }
}


/// <summary>
/// Aggregates a function that takes two arguments of 
/// TValue and returns a bool, across a sequence of T,
/// and returns true if all invocations return true,
/// or false otherwise. TValue arguments are obtained
/// from elements using the selector function.
/// 
/// </summary>

public static bool AllBy<T, TValue>(this IEnumerable<T> values, 
   Func<T, TValue> selector, 
   Func<TValue, TValue, bool> comparer)
{
   if(values == null)
      throw new ArgumentNullException(nameof(values));
   if(selector == null)
      throw new ArgumentNullException(nameof (selector));
   if(comparer == null)
      throw new ArgumentNullException(nameof(comparer));
   using(IEnumerator<T> e = values.GetEnumerator())
   {
      if(e.MoveNext())
      {
         TValue last = selector(e.Current);
         while(e.MoveNext())
         {
            TValue next = selector(e.Current);
            if(!comparer(last, next))
               return false;
            last = next;
         }
      }
      return true;
   }
}

public static void BinaryAllExample()
{
   int[] values = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

   /// true if the elements appear in ascending order:

   values.All((a, b) => a < b);

   (string Name, float Price)[] items =
      { ("Apples", 2.5f), ("Pears", 2.25f), ("Bananas", 1.5f) };

   /// true if elements appear in descending order by Price

   items.AllBy(item => item.Price, (price1, price2) => price1 > price2);

   // Using All() to determine if a list of
   // related items appear in related order:

   var item = new LinkedItem();
   List<LinkedItem> list = new List<LinkedItem>() { item };
   for(int i = 0; i < 10; i++)
      list.Add(item = new LinkedItem(item));

   // true if the LinkedItems in list are in linked order:

   list.All((a, b) => a.Next == b);
}

class LinkedItem
{
   public LinkedItem(LinkedItem prev = null)
   {
      prev.Next = this;
   }
   public LinkedItem Next { get; private set; }
}