var s = new[] {1, 3, 3, 7, 9};
var r = s.Aggregate(new {V=int.MinValue, C=0}, (a, val) => a.V < val ? new {V=val, C=a.C+1} : a).C == s.Length;

        public static IEnumerable<int> Enumerate()
        {
            ...
        }

        public static void Main(string[] args)
        {
            var ascending = Enumerate()
                .Memoize(1)
                .Let(e => e.Zip(e.Skip(1), (a, b) => a < b))
                .All(x => x);
        }

var isAscending = xs.OrderBy(x => x).SequenceEqual(xs);

var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);

  static void Main(string[] args)
        {
            var a = new[] { 1, 2, 3, 4, 5 };
            int last = 0;
            var asc = a.Select(x => { if (x >= last) { last = x; return true; } else return false; }).All(x=>x);
            Console.WriteLine(asc);
            

        }

П>>Неэффективно, но декларативненько:

П>>var isAscending = xs.OrderBy(x => x).SequenceEqual(xs);
П>>

П>>var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);
П>>

Помня одно предыдущее значение, соедини последовательность с самой собой, смещённой с на один элемент вперёд, и проверь, что во всех парах левое значение меньше или равно правому.

П>var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);
П>

var isAscending = sequence.Zip(sequence.Skip(1), (x, y) => x <= y).All(x => x);

П>>var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);
П>>

IB>var isAscending = sequence.Zip(sequence.Skip(1), (x, y) => x <= y).All(x => x);
IB>

            var sequence = new[] { 1, 2, 3, 4, 5, 6 }.Do(Console.Write);
            var isAscending = sequence
                .Zip(sequence.Skip(1), (x, y) => x <= y)
                .All(x => x); // 112233445566

            var sequence = new[] { 1, 2, 3, 4, 5, 6 }.Do(Console.Write).Memoize(1);
            var isAscending = sequence
                .Zip(sequence.Skip(1), (x, y) => x <= y)
                .All(x => x); //123456

            var sequence = new[] { 1, 2, 3, 2, 4, 5, 6 }.Do(Console.Write).Memoize(1);
            var isAscending = sequence
                .Zip(sequence.Skip(1), (x, y) => x <= y)
                .All(x => x); //1232

    class Seq : IEnumerable<int>
    {
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public IEnumerator<int> GetEnumerator()
        {
            Console.WriteLine("GetEnumerator");

            Console.WriteLine(1);
            yield return 1;

            Console.WriteLine(2);
            yield return 2;

            Console.WriteLine(3);
            yield return 3;

        }
    } 

    class Program
    {
        static void Main(string[] args) 
        {
            var sequence = new Seq();
//            var sequence = new Seq().Memoize(1);
            var isAscending = sequence
                .Zip(sequence.Skip(1), (x, y) => x <= y)
                .All(x => x); 
        }
    }

GetEnumerator
1
GetEnumerator
1
2
2
3
3

GetEnumerator
1
2
3

П>Насчёт "уродства" — императивные циклы с мутабельными переменными и break-переходом куда красивше, дааа

auto f(int Arr[])
{
    if(Arr.length < 2)
        return true;
    
    if(Arr[0] > Arr[1])
        return false;
    
    return f(Arr[0 .. $ - 1]);
}

П>Это просто другой "мирок", никто Вам не навязывает подобные техники и подходы. Ну не нравится — ну не пользуйтесь, проблем то

// Кейворд aliens помечает декларативный код для "других" людей.
aliens
{
    var isAscending = xs.Replay(ys => ys.Zip(ys.Skip(1), (x, y) => x <= y), 1).All(x => x);
}

// Кейворд bydlokod помечает императивный код.
bydlokod
{
    bool isAscending = true;

    for (int i = 1; i < numbers.Length; i++)
    {
        if (numbers[i - 1] > numbers[i])
        {
            isAscending = false;
            break;
        }
    }
}

SC>// Кейворд bydlokod помечает императивный код.
SC>bydlokod
SC>{
SC>    bool isAscending = true;
SC>    for (int i = 1; i < numbers.Length; i++)
SC>    {
SC>        if (numbers[i - 1] > numbers[i])
SC>        {
SC>            isAscending = false;
SC>            break;
SC>        }
SC>    }
SC>}
SC>

let isAscending xs = xs |> Seq.pairwise |> Seq.forall (fun (a,b) -> a <= b)