for(mutable i = 0, i < rank ; i++)

 foreach (i in [0 .. rank - 1])

 def  ret = return: { 
 ...

using Nemerle.Imperative;

F(): bool {
 foreach ( .. ) foreach (.. ) when ( .. ) return true;
 false
}

        def print2DArray(a: array[2, int], size)
        {
            for(mutable i = 0, i < 2 ; i++)
            {
                WriteLine();
                for(mutable j=0; j < size; j++)
                    Write("{0,3}", a[i,j]);
            }
        }

        def initArray(rank, size, init) 
        {
            def a = array(rank, size);
            for(mutable i = 0, i < rank ; i++)
                for(mutable j=0;j<size; j++)
                    a[i,j] = init();
            a
        }

module Program
{

    GetArray[T]() : array[2, T]
    {
        array.[2][];
    }
    
    Main() : void
    {
        def initArray(rank, size, init) 
        {
            def a = array(rank, size);
            for(mutable i = 0, i < rank ; i++)
                for(mutable j=0;j<size; j++)
                    a[i,j] = init();
            a
        }


        def printArray(a, rank, size)
        {
            for(mutable i = 0, i < rank ; i++)
            {
                WriteLine();
                for(mutable j=0;j < size; j++)
                    Write("{0,3}", a[i,j]);
            }
        }

        def mixArray(a, rank, size, repeatCount)
        {
            def rand = Random(Environment.TickCount);

            for(mutable i = 0, i < repeatCount ; i++)
            {
                def i1 = rand.Next(0,rank);
                def j1 = rand.Next(0,size);
                def i2 = rand.Next(0,rank);
                def j2 = rand.Next(0,size);
                unless(i1==i2 && j1==j2)
                {
                    def t = a[i1,j1];
                    a[i1,j1] = a[i2,j2];
                    a[i2,j2] = t;
                }
            }
        }

        def copyArray(a, rank, size)
        {
            def b = array(rank, size);
            for(mutable i = 0, i < rank ; i++)
                for(mutable j=0;j < size; j++)
                    b[i,j] = a[i,j];    
            b
        }

        def checkArray(a, b, rank, size)
        {
            def  ret = return: { 
                for(mutable i = 0, i < rank ; i++)
                    for(mutable j=0;j < size; j++)
                        when( b[i,j] != a[i,j])
                            return (false);
                true;}

            ret;
        }

        mutable x = -1;

        def g () 
        {
            x++;
            x
        }     

        def a = initArray(4,4, g);
        def e = copyArray(a,4,4);

        WriteLine(checkArray(a,e,4,4));

        repeat(10)
            mixArray(a,4, 4, 10);

        WriteLine(checkArray(a,e,4,4));
        printArray(a,4, 4);
        WriteLine($"\n\r$(String('#',80))");

        def s = GetArray.[string]();            

        _ = ReadLine();
    }

_NN>> def  ret = return: { 
_NN>> ...
_NN>>

a[i1,j1] <-> a[i2, j2]

//def t = a[i1,j1];
//a[i1,j1] = a[i2,j2];
//a[i2,j2] = t;

-- haskell

quicksort [] = []
quicksort (p:xs) = (quicksort lesser) ++ [p] ++ (quicksort greater)
    where
        lesser = filter (< p) xs
        greater = filter (>= p) xs

-- или такой вариант, близок к варианту на Эрланге ниже

quicksort [] = []
quicksort (x:xs) =
  let smallerSorted = quicksort [a | a <- xs, a <= x]
      biggerSorted = quicksort [a | a <- xs, a > x]
  in  smallerSorted ++ [x] ++ biggerSorted

# erlang

qsort([]) -> [];
qsort([Pivot|T]) ->
       qsort([X || X <- T, X < Pivot])
       ++ [Pivot] ++
       qsort([X || X <- T, X >= Pivot]).