def result =
  if (condition)
  {
    kjsdhfjklasdh()
  }
  else
  {
    werioptuertj();
  }
    
Calc(result)

ИД>>>def dx = Nemerle.Utility.NArray.Map (cf, _ * ck);
ИД>>>

def ary = array[1,2,3];
def lst = ary.Map(elem => (elem * elem).ToString());
WriteLine(lst); // в lst содержится список строк

def mulTo10(x)
{
  x * 10
}

x => x * 10

_ * 10

def x = 10;
_ * x

let x = 1 in
let x = x * 22 in
x;;

int x = 1;
{
  float x = 22.0f;
  std::cout << x << std::endl;
}

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

                
FDS>                def Lf = cf.Length;
FDS>                def dx = array(Lf);
FDS>                for (mutable i = 0; i < Lf; i++)
FDS>                {
FDS>                    dx[i] = cf[i] * ck;
FDS>//                    Console.WriteLine($"$(cf[i]) * $(ck)");
FDS>                }

def dx = Nemerle.Utility.NArray.Map (cf, _ * ck);

FDS>                    for (mutable i = 0; i < Lf; i++)
FDS>                    {
FDS>                        dx[i] += incDx[i];
FDS>                    }

FDS>>                def Lf = cf.Length;
FDS>>                def dx = array(Lf);
FDS>>                for (mutable i = 0; i < Lf; i++)
FDS>>                {
FDS>>                    dx[i] = cf[i] * ck;
FDS>>//                    Console.WriteLine($"$(cf[i]) * $(ck)");
FDS>>                }
ИД>

ИД>def dx = Nemerle.Utility.NArray.Map (cf, _ * ck);
ИД>

using Nemerle.Utility;
...
def x = cf.Map(_ * ck);

FDS>>                    for (mutable i = 0; i < Lf; i++)
FDS>>                    {
FDS>>                        dx[i] += incDx[i];
FDS>>                    }
ИД>

ИД>Вот тут простой библиотечной функцией не заменить (пока?). Можно конечно что-то такое def dx = Map2 (dx, ToList (incDx), _ + _).ToArray (), но не стоит

for (mutable i = 0; i < Lf; i++)
    dx[i] += incDx[i];

for (mutable i = 0; i < dx.Length; i++)
    dx[i] += incDx[i];

def result =
  if (condition)
  {
    kjsdhfjklasdh()
  }
  else
  {
    def result = werioptuertj();
    CallAnotherMethod();
    result
  }
    
Calc(result)

def result =
  if (flag1 && {
    def flag2 = CallLongOperation();
    flag2 && flag3 || !flag2 && flag4
  })
  {
    kjsdhfjklasdh()
  }
  else
  {
    werioptuertj();
  }
    
Calc(result)

FDS>Вот, а у меня всё нормально работает для списков разной длины, так что у меня правильней

        def GetDx(_, _)
        {
        | ([ck], cf :: _flast) =>
            (cf.Map(_ * ck), [])
            
        | (ck :: klast, cf :: flast) =>
            def (incDx, cflast) = GetDx(klast, flast);
            (cf.MapI((i, f) => f * ck + incDx[i]), cf :: cflast)
        
        | _ => throw Exception();//Если второй короче или если первый пуст
        }

D>def result = if (condition) kjsdhfjklasdh() else werioptuertj();
D>Calc(result)
D>

Calc(if (condition) kjsdhfjklasdh() else werioptuertj())

ИД>>def dx = Nemerle.Utility.NArray.Map (cf, _ * ck);
ИД>>

def dx = cf * ck;
dx += incDx;
CalculatedPoints[CalcI] = 0 :: (dx * t * k + CalculatedPoints[CalcI - 1].ChopFirst(1));

$(init)
goto check;
loop:
$(body)
check:
if $(cond)
  goto loop;

$(init)
check:
if ! $(cond)
  goto end;
$(body)
goto check;
end:

VD>>def result = if (condition) kjsdhfjklasdh() else werioptuertj();
VD>>

def result = 
        if( cond ) {
            def i = 0;
            while( arr[i] < func(arr[i]) && cond1 ) i++;
            i;
        }
        else proc_another(arr[0]);

def result = match( list ) {
     | x :: _ when x > 0 => -x;
     | x :: _ => x;
     | x :: [] => x+1;
   }

def result = if (condition) kjsdhfjklasdh() else werioptuertj();
Calc(result)

IT>def result =
IT>  if (condition)
IT>  {
IT>    kjsdhfjklasdh()
IT>  }
IT>  else
IT>  {
IT>    werioptuertj();
IT>  }
    
IT>Calc(result)
IT>

def result = if (condition) kjsdhfjklasdh() else werioptuertj();

VD>>Calc(if (condition) kjsdhfjklasdh() else werioptuertj())
VD>>

Calc(condition ? kjsdhfjklasdh() : werioptuertj())

                fres = 
                
                if (klast != [])
                {
                    def (incDx, cflast) = GetDx(klast, flast);
                    for (mutable i = 0; i < Lf; i++)
                    {
                        dx[i] += incDx[i];
                    }
                    cf::cflast;
                }
                else
                {
                    [];
                };

public module IntegrationSchems
    {
// .....

        public Adams5k: list[double] = [1901.0, -2774.0, 2616.0, -1274.0, 251.0];
        public Adams5c: double = 1.0/720.0;        

        // Общая реализация схем Адамса
        // K : массив коэффициентов для суммы функций
        // k : множитель при всей сумме (т.е. множитель при величине шага)
        // CalculatedPoints: массив уже вычисленных точек
        // CalcI - номер текущей точки, подлежащей вычислению
        // f - функция для вычисления правой части уравнений
        // F - объект, хранящий уже вычисленные правые части уравнений
        public Adams(K: list[double], k : double, CalculatedPoints: array[2, double], CalcI: int, f: array[double], F: list[array[double]]): list[array[double]]
        {

            def GetDx(K, F)
            {
                def (ck: double :: klast) = K;
                def (cf: array[double] :: flast) = F;
                
                def Lf = cf.Length;
                
                mutable fres;
                
                def dx = array(Lf);
                for (mutable i = 0; i < Lf; i++)
                {
                    dx[i] = cf[i] * ck;
//                    Console.WriteLine($"$(cf[i]) * $(ck)");
                }

                if (klast != [])
                {
                    def (incDx, cflast) = GetDx(klast, flast);
                    for (mutable i = 0; i < Lf; i++)
                    {
                        dx[i] += incDx[i];
                    }
                    fres = cf::cflast;
                }
                else
                {
                    fres = [];
                };
                
                (dx,  fres)
            }

            def SetNewPoint(dx, t)
            {
                def L = CalculatedPoints.GetLength(0);
                for (mutable i = 1; i < L; i++)
                {
                    CalculatedPoints[i, CalcI] = dx[i - 1] * t * k + CalculatedPoints[i, CalcI - 1];
                }
            }

            // Шаг интегрирования
            def t = CalculatedPoints[0, CalcI] - CalculatedPoints[0, CalcI - 1];
        
            def (dx, result) = GetDx(K, f :: F);

            SetNewPoint(dx, t);
                        
            result;
        }
        
        // Метод Рунге-Кутты
        public RK(K: list[list[double]],
                  CalculatedPoints: array[2, double],
                  CalcI: int, I0: int, I1: int, f: int *int * int * double * array[1, double] -> array[double], F: list[array[double]]): list[array[double]]
        {
            def L      = CalculatedPoints.GetLength(0);
            def t      = CalculatedPoints[0, CalcI] - CalculatedPoints[0, CalcI - 1];
        
            def (kList :: ktail) = K;
            def (k :: klt)       = kList;
            
            mutable RKresult: array[double] = array(L - 1);

            
            // Обяъвления типов из-за забытого индекса: иначе сообщения об ошибке выдавались не там, где надо из-за того,
            // что компилятор думал, что типы передаваемых значений другие
            // К тому же так просто более понятен смысл
            
            // Получить список вспомогательных коэффициентов
            // В каждом списке в k содержимое: [множитель при t, множитель при младшем (с меньшим индексом) коэффициенте, .., при старшем коэффициенте]
            def GetKs(k: list[list[double]], fn: list[array[double]])
            {
                // Найти приращение к аргументу x функции f (т.е. f(x + Ksm, t + t * kt) )
                def GetKsm(kn: list[double], fn: list[array[double]])
                {
                    if (fn == [] || kn == [])
                    {
                            def result = array(L);
                            for (mutable i = 0; i < L - 1; i++)
                            {
                                result[i] = 0.0;
                            }
                            result;
                    }
                    else
                    {
                        def (fi :: ftail) = fn;
                        def (k  :: ktail) = kn;

                        def result = MGauss.MatrixCopy(fi);
                        for (mutable i = 0; i < L - 1; i++)
                        {
                            result[i] *= k;
                        }

                        if (ktail != [])
                        {
                            def Ksm    = GetKsm(ktail, ftail);
                            for (mutable i = 0; i < L - 1; i++)
                            {
                                result[i] += Ksm[i];
                            }
                            result;
                        }
                        else
                        {
                            result;
                        }
                    }
                }

                def (kf :: ktail) = k;
                def (kt :: kn)    = kf;
                
                
                def xn  = array(L - 1);
                def Ksm = GetKsm(kn, fn);
                
                for (mutable i = 0; i < L - 1; i++)
                {
                    xn[i] = CalculatedPoints[i + 1, CalcI - 1] + Ksm[i];
                }

                // Найти приращение к t (т.е. f(x + Ksm, t + t * kt)
                def tn = t * kt + CalculatedPoints[0, CalcI - 1];
                
                def fi = f(CalcI, I0, I1, tn, xn);
                

                if (fn == [])
                {
                    for (mutable i = 0; i < L - 1; i++)
                      RKresult[i] = fi[i];
                }
                else {};

                
                for (mutable i = 0; i < L - 1; i++)
                {
                    fi[i] *= t;
                }                

                if (ktail != [])
                    GetKs(ktail, fi::fn);
                else
                    fi::fn;                     // старший коэффициент (с большим индексом) в начале списка
            }
            
            
            
            // Просуммировать их с соотв. коэффициентами, получив приращение
            // В k - [общий множитель, множитель при старшем коэффициенте, ..., множитель при младшем коэффициенте ]
            def GetSummK(k: list[double], ks: list[array[double]])
            {
                def result = array(L - 1);
                
                // Вычислить следующее слагаемое суммы
                def GetSumm(k, ks): void
                {
                    def (kl  :: klt ) = k;
                    def (ksl :: kslt) = ks;

                    for (mutable i = 0; i < L - 1; i++)
                    {
                        result[i] += kl * ksl[i];
                    }

                    if (klt != [])
                    {
                        GetSumm(klt, kslt);
                    }
                    else {};
                }
            
                def (kl  :: klt ) = k;
                def (ksl :: kslt) = ks;
                
                // Первое слагаемое суммы вычислить тут, так как всё равно нужно инициализировать массив
                for (mutable i = 0; i < L - 1; i++)
                {
                    result[i] = kl * ksl[i];
                }
                
                if (klt != [])
                {
                    GetSumm(klt, kslt);
                }
                else {};
                
                result;
            }
            
            
            def ks     = GetKs   (ktail, []);   // Получить список вспомогательных коэффициентов и result
            def dx     = GetSummK(klt, ks);     // Просуммировать их с соотв. коэффициентами, получив приращение

            for (mutable i = 1; i < L; i++)
            {
                CalculatedPoints[i, CalcI] = k * dx[i - 1] + CalculatedPoints[i, CalcI - 1];
            }

            RKresult :: F;                    // Результат функции - список вычисленных значений правых частей в точках интегрирования
        }
        
// ....

FDS>                fres = 
                
FDS>                if (klast != [])
FDS>                {
FDS>                    def (incDx, cflast) = GetDx(klast, flast);
FDS>                    for (mutable i = 0; i < Lf; i++)
FDS>                    {
FDS>                        dx[i] += incDx[i];
FDS>                    }
FDS>                    cf::cflast;
FDS>                }
FDS>                else
FDS>                {
FDS>                    [];
FDS>                };
FDS>

                    def ApplyDx(incDx, cflast)
                    {
                        for(i in [0..Lf-1])
                            dx[i] += incDx[i];
                        cf :: cflast
                    }
                    def fres = if (klast is []) [] else ApplyDx(GetDx(klast, flast));

FDS>                fres = 
                
FDS>                if (klast != [])
FDS>                {
FDS>                    def (incDx, cflast) = GetDx(klast, flast);
FDS>                    for (mutable i = 0; i < Lf; i++)
FDS>                    {
FDS>                        dx[i] += incDx[i];
FDS>                    }
FDS>                    cf::cflast;
FDS>                }
FDS>                else
FDS>                {
FDS>                    [];
FDS>                };
FDS>

def fres = 
    if (klast != [])
    {
            def (incDx, cflast) = GetDx(klast, flast);
            foreach (i in $[0..Lf - 1])
                    dx[i] += incDx[i];
            cf :: cflast;
    }
    else [];

public module IntegrationSchems
{
    public MapI [From, To] (this from : array [From], f : int * From -> To) : array [To]
    {
      if (from == null)
        array(0)
      else
      {
        def result = array (from.Length);

        for (mutable i = 0; i < from.Length; ++i)
          result [i] = f (i, from [i]);

        result
      }
    }


    public Adams5k: list[double] = [1901.0, -2774.0, 2616.0, -1274.0, 251.0];
    public Adams5c: double = 1.0/720.0;        

    // Общая реализация схем Адамса
    // K : массив коэффициентов для суммы функций
    // k : множитель при всей сумме (т.е. множитель при величине шага)
    // CalculatedPoints: массив уже вычисленных точек
    // CalcI - номер текущей точки, подлежащей вычислению
    // f - функция для вычисления правой части уравнений
    // F - объект, хранящий уже вычисленные правые части уравнений
    public Adams // когда у функции много параметров их нужно разносить на разные строчки. Так лучше читается.
        ( K : list[double]
        , k : double
        , CalculatedPoints : array[2, double]
        , CalcI : int
        , f : array[double]
        , F : list[array[double]]
        ) : list[array[double]]
    {

        def GetDx(_, _)
        {
        | ([ck], [cf]) =>
            (cf.Map(_ * ck), [])
            
        | (ck :: klast, cf :: flast) =>
            def (incDx, cflast) = GetDx(klast, flast);
            (cf.MapI((i, f) => f * ck + incDx[i]), cf :: cflast)
        
        | _ => throw Exception();//Если списки разной длинны.
        }

//Дальше не переписывал
        def SetNewPoint(dx, t)
        {
            def L = CalculatedPoints.GetLength(0);
            for (mutable i = 1; i < L; i++)
            {
                CalculatedPoints[i, CalcI] = dx[i - 1] * t * k + CalculatedPoints[i, CalcI - 1];
            }
        }

        // Шаг интегрирования
        def t = CalculatedPoints[0, CalcI] - CalculatedPoints[0, CalcI - 1];
    
        def (dx, result) = GetDx(K, f :: F);

        SetNewPoint(dx, t);
                    
        result;
    }
    public Main() : void
    {
    }    
}

foreach(i in $[0..n])
    ...

VK>foreach(i in [0..n-1])
VK>

public Equals(Dat: Data): bool
  def walk_array (i)
    i >= count || (data[i]==Dat.data[i] && walk_array (i + 1))
  if (count != Dat.Count) false
  else walk_array(0)

def LoopSelfData(i,j,k,p:int)
  data[i] =  Arr[j] |> _/p:double
  if (i == count-1) ()
  else if (k == p) LoopSelfData(i+1,j+1,1,p)
  else LoopSelfData(i+1,j,k+1,p)

Calc()

Calc(CauchyBasis)

Calc(CauchyBasis, ResultTransitions)

MarkTree(tree)

MarkTree(tree, vect)
{
  if ( isNull( ScalarMul(vect, GetVectorValue(tree) ) ) )
  {
    MarkTree;
  }
  else {};
}

  def smr = ScalarMul( vect, GetVectorValue(tree) );
  if ( isNull( smr ) )
  {
    MarkTree;
  }
  else {};

FDS>MarkTree(tree)
FDS>

FDS>MarkTree(tree, vect)
FDS>{
FDS>  if ( isNull( ScalarMul(vect, GetVectorValue(tree) ) ) )
FDS>  {
FDS>    MarkTree;
FDS>  }
FDS>  else {};
FDS>}
FDS>

FDS>  def smr = ScalarMul(vect, GetVectorValue(tree));
FDS>  if ( isNull( smr ) )
FDS>  {
FDS>    MarkTree;
FDS>  }
FDS>  else {};
FDS>

TraverseTree(node : Node) : IEnumerable[Node]
{
    yield node;
    TraverseTree(node.Left);
    TraverseTree(node.Right);
}
...
foreach (node in TraverseTree(tree.Root))
    when (isNull(ScalarMul(vect, GetVectorValue(node))))
      MarkTree(node);

#pragma indent
using System
using System.Console
using Nemerle.Collections
using Nemerle.Diagnostics

def sum = _ + _

def fermat_t(n)
    def q = $[1..n]
    q.FoldLeft(0,sum)
    
def fer_t(n)
    def ferm_t(x,acc)
        match(x)
            | 0 => acc
            | _ => ferm_t(x-1,acc+x)
    ferm_t(n,0)
    
def fermat_p(n)
    $[1..n].Map(fermat_t).FoldLeft(0,sum)

def fer_p(n,acc=0)
    match(n)
        | 0 => acc
        | _ => fer_p(n-1,acc+fer_t(n))
        
def factorial(n)
    $[1..n].FoldLeft(1,_*_)

def fact(n,acc=1)
    match(n)
        | 1 => acc
        | _ => fact(n-1,acc*n)
        
def factoriallist(n)
    $[1..n].Map(factorial)
    
def fibonacci(n)
    | 0 | 1 => 1
    | _ => fibonacci(n-2) + fibonacci(n-1)
    
def fibonaccilist(n)
    $[1..n].Map(fibonacci)

WriteLine(fermat_t(1))
WriteLine(fer_t(1))
WriteLine(fermat_t(2))
WriteLine(fer_t(2))
WriteLine(fermat_t(3))
WriteLine(fer_t(3))
WriteLine(fermat_p(1))
WriteLine(fer_p(1))
WriteLine(fermat_p(2))
WriteLine(fer_p(2))
WriteLine(fermat_p(3))
WriteLine(fer_p(3))
WriteLine(fermat_p(4))
WriteLine(fer_p(4))
WriteLine(factorial(5))
WriteLine(fact(5))
WriteLine(fact(10))
WriteLine(factoriallist(5))
WriteLine(fibonacci(5))
WriteLine(fibonaccilist(5))
time repeat (10000000) _ = factorial(10)
time repeat (10000000) _ = fact(10)
time repeat (10000000) _ = factorial(5)
time repeat (10000000) _ = fact(5)
time repeat (1000000) _ = fermat_p(20)
time repeat (1000000) _ = fer_p(20)
time repeat (10000000) _ = fermat_p(5)
time repeat (10000000) _ = fer_p(5)
_ = ReadLine()

    public ApplyFunc(f: Vals->Vals): void
      for (mutable i = 0; i < count; i++)
        data[i] = f(data[i])
    
    public ApplyFuncFE(f: Vals->Vals): void
      foreach (i in $[0..count-1])
        data[i] = f(data[i])
    
    public ApplyFuncM(f: Vals->Vals): void
      data = data.Map(f)
      
    public ApplyFuncC(f: Vals->Vals): void
      data = data.ConvertAll(f)
      
    public ApplyFuncL(f: Vals->Vals): void
      def Loop(i)
        data[i] = f(data[i])
        if (i == count-1) ()
        else Loop(i+1)
      Loop(0)
          
    public ApplyFuncI(f: int*Vals->Vals): void
      for (mutable i = 0; i < count; i++)
        data[i] = f(i+1,data[i])
    
    public ApplyFuncIFE(f: int*Vals->Vals): void
      foreach (i in $[0..count-1])
        data[i] = f(i+1,data[i])
        
    public ApplyFuncIM(f: int*Vals->Vals): void
      data = Map2(data,$[1..count],(x,y)=>(y,x)).Map(f).ToArray()
    
    public ApplyFuncIL(f: int*Vals->Vals): void
      def Loop(i)
        data[i] = f(i+1,data[i])
        if (i == count-1) ()
        else Loop(i+1)
      Loop(0)
      
    public static Bench(apf: (Vals->Vals)->void, f: Vals->Vals, c: long, m: string): void
      WriteLine($"Bench $m function $c times:")
      time repeat(c) apf(f)
      
    public static BenchI(apfi: (int*Vals->Vals)->void, f: int*Vals->Vals, c: long, m: string): void
      WriteLine($"Bench $m function $c times:")
      time repeat(c) apfi(f)

def l = ["PArAM_Simple","INGIS_Izm(Mon):34124","PIRAMIDA_Izm(3M):13:15","CK_Avg:7"]
def lp = l.Map(_:>Par)
// Первый две строки не так важны
mutable i = 0
time repeat(100000) Array.ForEach(Array.ConvertAll(lp.ToArray(),_.ToString),_x=>i++)
WriteLine(i)
i = 0
time repeat(100000) lp.Map(_.ToString()).Iter(_x=>i++)
WriteLine(i)
i = 0
time repeat(100000) Array.ForEach(lp.Map(_.ToString()).ToArray(),_x=>i++)
WriteLine(i)

VD>Хм. Интересно... Правда не очень похоже на творчество для дома, для семьи.

VD>TraverseTree(node : Node) : IEnumerable[Node]
VD>{
VD>    yield node;
VD>    TraverseTree(node.Left);
VD>    TraverseTree(node.Right);
VD>}
VD>...
VD>foreach (node in TraverseTree(tree.Root))
VD>    when (isNull(ScalarMul(vect, GetVectorValue(node))))
VD>      MarkTree(node);
VD>

MarkNode(tree)
{
  def sm = ScalarMul(vect, GetVectorValue(node))
  when ( isNull(sm) )
    /// ....
}


MarkTree(tree): tree
{
  MarkNode(tree);  

  MarkTree(tree.left);
  MarkTree(tree.right)

  tree
}

if
(
  Function1
  (
    Function2(),
    Function3
    (
      Function4()
    )
  )
)
{
  Function5();
  Function6();
}

VD>for (mutable i = 0; i < Lf; i++)
VD>    dx[i] += incDx[i];
VD>

VD>for (mutable i = 0; i < dx.Length; i++)
VD>    dx[i] += incDx[i];
VD>

using System;
using System.Console;
using Nemerle.Utility;

module Program
{
    Main() : void
    {
        def count = 10_000_000;
        def dx : array[int] = array(count);
        def incDx : array[int] = array(count);
    
        def timing(unit : void->void)
        {
            unit();
            def sw = System.Diagnostics.Stopwatch();
            sw.Start();
            unit();
            sw.Stop();
            WriteLine(sw.ElapsedTicks);
        }
    
        timing( () => {
            for (mutable i = 0; i < dx.Length; i++)
                dx[i] += incDx[i];
        });
        
        timing( () => {
            def len = dx.Length;
            for (mutable i = 0; i < len; i++)
                dx[i] += incDx[i];
        });
    
        _ = ReadLine();
    }
}

506100502
345686186

C#
163164
160065

Немерле
404236
264025

        def GetDx(_, _)
        {
        | ([ck], [cf]) =>
            (cf.Map(_ * ck), [])
            
        | (ck :: klast, cf :: flast) =>
            def (incDx, cflast) = GetDx(klast, flast);
            (cf.MapI((i, f) => f * ck + incDx[i]), cf :: cflast)
        
        | _ => throw Exception();//Если списки разной длинны.
        }

| ([ck], [cf]) => ...

| (ck :: klast, cf :: flast) => ...