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

// Кейворд 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;
        }
    }
}

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

П>>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);
П>>

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

        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 = new[]{1, 3, 5, 7, 9}.Reduce((a, b) => a <= b).And();

П>>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

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);

U>| h::t                  -> f t
U>

| h1::h2::tl -> f tl

let rec iter2 f l1 l2 =
  match (l1, l2) with
    ([], []) -> ()
  | (a1::l1, a2::l2) -> f a1 a2; iter2 f l1 l2
  | (_, _) -> invalid_arg "List.iter2"

class Tree
{
    public Tree Left;
    public Tree Right;
}

int RecursiveNodeCount(Tree root)
{
    if (root == null)
    {
        return 0;
    }

    return RecursiveNodeCount(root.Left) + RecursiveNodeCount(root.Right);
}

int NodeCount(Tree tree)
{
    var unvisitedNodes = new Stack<Tree>();
    unvisitedNodes.Push(root);

    var count = 0;
    while (!unvisitedNodes.IsEmpty)
    {
        var node = unvisitedNodes.Pop();
        while (node != null)
        {
            ++count;
            node = node.Left;
            unvisitedNodes.Push(node.Right);
        }
    }

    return count;
}

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

pure auto f(int Arr[])
{
00402010  sub         esp,20h 
00402013  mov         ecx,dword ptr [esp+28h] 
    if(Arr.length < 2)
00402017  push        ebx  
00402018  push        esi  
00402019  mov         esi,dword ptr [esp+2Ch] 
0040201D  cmp         esi,2 
00402020  push        edi  
00402021  jae         main@f+21h (402031h) 
        return true;
00402023  pop         edi  
00402024  mov         eax,1 
00402029  pop         esi  
0040202A  pop         ebx  
0040202B  add         esp,20h 
0040202E  ret         8    
    
    if(Arr[0] > Arr[1])
00402031  mov         edx,ecx 
00402033  mov         ebx,dword ptr [edx] 
00402035  mov         eax,esi 
00402037  cmp         ebx,dword ptr [edx+4] 
0040203A  jle         main@f+37h (402047h) 
        return false;
0040203C  pop         edi  
0040203D  xor         eax,eax 
0040203F  pop         esi  
00402040  pop         ebx  
00402041  add         esp,20h 
00402044  ret         8    
    
    return f(Arr[1 .. $]);
00402047  lea         edi,[esi-1] 
0040204A  add         edx,4 
0040204D  mov         ecx,edx 
0040204F  mov         dword ptr [esp+0Ch],edi 
00402053  mov         esi,edi 
00402055  mov         dword ptr [esp+10h],edx 
00402059  cmp         dword ptr [esp+0Ch],2 
0040205E  jb          main@f+13h (402023h) 
00402060  jmp         main@f+21h (402031h)

  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);
            

        }

int[] a = { 1, 2, 3, 4, 5 };

bool isAscending = !a.Skip(1).Where((x, i) => x < a[i]).Any();

bool isAscending = a.Zip(a.Skip(1), (x, y) => x <= y).All(x => x);

            int p = int.MinValue;
            if (arr.Any(x => p > (p = x) ))
                Console.WriteLine("Не упорядочена");

П>>| h1::h2::tl -> f tl
П>>

let rec f = function 
    | a::b::_  when a > b   -> false
    | h::t                  -> f t
    | _                     -> true

let rec f xs =
    match xs with
    | a::b::_  when a > b   -> false
    | h::t                  -> f t
    | _                     -> true

Я>

int RecursiveNodeCount(Tree root)
{
    if (root == null)
    {
        return 0;
    }

    var right = root.Right;
    return 1 + RecursiveNodeCount(root.Left) + RecursiveNodeCount(right);
}

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;

П>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);

    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]);
}

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)

  bool isAscending = vars.Aggregate<int, int?>(0, (prev, item) => prev == null || item <= prev ? null : (int?)item) != null;

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

П>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);
П>

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

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

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

for (int i = 1; i < arr.Length; ++i)
{
   if (arr[i] <= arr[i-1])
     return false;
}
return true;

П>>Например, свёртка — фундаментальная операция над списками и ещё много чем — требует как раз промежуточного значения под аккумулятор

Приведенная задача требует хранения промежуточного значения, т.е. является императивной

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

            var arr = new int[] { 1, 6, 7, 8, 9, 7 };

            int p = arr[0];
            if (arr.Any(x => p > (p = x) ))
                Console.WriteLine("Не упорядочена");
            else
                Console.WriteLine("Упорядочена");

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

let rec f = function 
  | a::b::_  when a > b   -> false
  | h::t                  -> f t
  | _                     -> true

let f l = pairwise l |> for_all (fun (a, b) -> a <= b)

myDropWhile p = foldr (++) [] . unfoldr st
    where
      st []     = Nothing
      st (x:xs) = if p x then Just ([],xs) else Just ((x:xs),[])

А>Ну многие вещи через goto тоже проще и короче сделать

А>myDropWhile p = foldr (++) [] . unfoldr st
А>    where
А>      st []     = Nothing
А>      st (x:xs) = if p x then Just ([],xs) else Just ((x:xs),[])
А>

dropWhile p [] = []
dropWhile p x:xs = if p x then dropWhile p xs else (x:xs)

isOrdered [] = true
isOrdered [_] = true
isOrdered a:b:xs = (a<b) && isOrdered (b:xs)

| h::t                  -> f t

int RecursiveNodeCount(Tree root, Func<int, int> continuation)
{
    if (root == null)
    {
        return continuation(0);
    }

    return RecursiveNodeCount(
        root.Left,
        leftCount =>
            RecursiveNodeCount(
                root.Right,
                rightCount => continuation(1 + leftCount + rightCount)));
}

int RecursiveNodeCount(Tree root)
{
    return RecursiveNodeCount(root, x => x);
}

U>| h::t                  -> f t
U>

type 'a list = [] | :: of 'a * 'a list

 a::b::tail -> ...

int RecursiveNodeCount(Tree root)
{
    if (root == null)
    {
        return 0;
    }

    return 1 + RecursiveNodeCount(root.Left) + RecursiveNodeCount(root.Right);
}