Кстати, среди нововведений версии 0.174 есть ключик командной строки -v1, который включает поддержку совместимости с версией 1.0 языка. Значит ли это, что 1.0 уже была?

R delegate() CurryAll(Dummy=void, R, U...)(R function(U) dg, U args)
{
    struct Foo
    {
        typeof(dg) dg_m;
        U args_m;

        R bar()
        {
            return dg_m(args_m);
        }
    }

    Foo* f = new Foo;
    f.dg_m = dg;
    foreach (i, arg; args)
        f.args_m[i] = arg;
    return &f.bar;
}

R delegate() CurryAll(R, U...)(R delegate(U) dg, U args)
{
    struct Foo
    {
        typeof(dg) dg_m;
        U args_m;

        R bar()
        {
            return dg_m(args_m);
        }
    }

    Foo* f = new Foo;
    f.dg_m = dg;
    foreach (i, arg; args)
        f.args_m[i] = arg;
    return &f.bar;
}

void main()
{
    static int plus(int x, int y, int z)
    {
        return x + y + z;
    }

    auto plus_two = CurryAll(&plus, 2, 3, 4);
    printf("%d\n", plus_two());
    assert(plus_two() == 9);

    int minus(int x, int y, int z)
    {
        return x + y + z;
    }

    auto minus_two = CurryAll(&minus, 7, 8, 9);
    printf("%d\n", minus_two());
    assert(minus_two() == 24);
}

Platform

Q: Why use CLI/.NET?


Mainly for interop reasons. There are number of CLI libraries and bindings out there already. There is going to be more and more.

Surely we'll loose WRT to compiled OCaml in terms of performance, at least until JIT's are made perfect, but it is easily possible to write a Gtk, GNOME, Windows GUI or even KDE application, we can embed Nemerle into ASP.NET web pages and there are more and more applications and libraries supporting .NET now. It is also possible to write libraries for other .NET languages, like C# or VB.NET.

We have also avoided significant development costs, because of this decision (no need for low-level compiler, JIT, the runtime library).

R delegate() CurryAll(Dummy=void, R, U...)(R function(U) dg, U args)
{
    struct Foo
    {
        typeof(dg) dg_m;
        U args_m;

        R bar()
        {
            return dg_m(args_m);
        }
    }

    Foo* f = new Foo;
    f.dg_m = dg;
    foreach (i, arg; args)
        f.args_m[i] = arg;
    return &f.bar;
}

R delegate() CurryAll(R, U...)(R delegate(U) dg, U args)
{
    struct Foo
    {
        typeof(dg) dg_m;
        U args_m;

        R bar()
        {
            return dg_m(args_m);
        }
    }

    Foo* f = new Foo;
    f.dg_m = dg;
    foreach (i, arg; args)
        f.args_m[i] = arg;
    return &f.bar;
}

void main()
{
    static int plus(int x, int y, int z)
    {
        return x + y + z;
    }

    auto plus_two = CurryAll(&plus, 2, 3, 4);
    printf("%d\n", plus_two());
    assert(plus_two() == 9);

    int minus(int x, int y, int z)
    {
        return x + y + z;
    }

    auto minus_two = CurryAll(&minus, 7, 8, 9);
    printf("%d\n", minus_two());
    assert(minus_two() == 24);
}

using Nemerle;
using System.Console;

def plus(x,y,z){ x+y+z }

def minus(x,y,z){ x-y-z }

def plus_two = plus(2,_,_);
WriteLine($"$(plus_two(6, 8))");

def plus_three = plus_two(3,_);
WriteLine($"$(plus_three(7))");

def plus_all = lazy( plus(7,8,9) );
WriteLine($"$plus_all");

def minus_all = lazy( minus(7,8,9) );
WriteLine($"$minus_all");

void main()
{
    static int plus(int x, int y, int z)
    {
            return x + y + z;
    }

    auto curried_plus = RealCurry(&plus);
    auto plus_two = curried_plus(2);
    auto plus_two_plus_three = plus_two(3);

    writefln(plus_two_plus_three(4)); // 9
    writefln(plus_two(5)(6));         // 13 
}

Scala 2 doesn't yet have support for .NET but it's in the making.
The .NET related information at the Scala website is only relevant for
Scala 1.4.

def make_dist(trx_count, quantum_count)
  result = []
  remaining_trx = trx_count
  remaining_quantums = quantum_count
  (1..quantum_count).each do |i|
    result << (remaining_trx.to_f / remaining_quantums).round
    remaining_trx -= result.last
    remaining_quantums -= 1
  end

  result
end

r = make_dist( 2, 6 )
puts r.join(',')

import std.math;

int[] makeDistrib( int trxCount, int quantums )
  {
    auto r = new int[ quantums ];
    auto remainingTrx = trxCount;
    auto remainingQuantums = quantums;
    for( int i = 0; i != r.length; ++i )
      {
        r[ i ] = cast(int)std.math.round(
            cast(float)remainingTrx / remainingQuantums );
        remainingTrx -= r[ i ];
        --remainingQuantums;
      }

    return r;
  }

int main()
  {
    int[] d = makeDistrib( 2, 6 );
    foreach( i; d )
      printf( "%i,", i );

    return 0;
  }

object BufferizatorDistrib
  {
    def makeDist( trxCount: int, quantums: int ) : Array[ int ] =
      {
        var r = new Array[ int ]( quantums )
        var i = 0
        var remainingTrx = trxCount
        var remainingQuantums = quantums
        while( i != quantums )
          {
            r(i) = Math.round(remainingTrx.toFloat / remainingQuantums)
            remainingTrx = remainingTrx - r(i)
            remainingQuantums = remainingQuantums - 1
            i = i + 1 
          }
        r
      }

    def main( args: Array[ String ] ) =
      {
        val d = makeDist( 2, 6 )
        for( val i <- d )
          System.out.print( i + "," )
      }
  }

object BufferizatorDistrib2
  {
    def makeDist( trxCount: int, quantums: int ) : Array[ int ] =
      {
        def nextValue( r: Array[ int ],
            place: int,
            remainingTrx: int,
            remainingQuantums: int ) : Array[ int ] =
            {
              r(place) = Math.round(remainingTrx.toFloat / remainingQuantums)
              if( remainingQuantums > 1 )
                nextValue( r, place + 1, remainingTrx - r(place), remainingQuantums - 1 )
              else r
            }

        nextValue( new Array[ int ]( quantums ), 0, trxCount, quantums )
      }

    def main( args: Array[ String ] ) =
      {
        val d = makeDist( 2, 6 )
        for( val i <- d )
          System.out.print( i + "," )
      }
  }

object BufferizatorDistrib3
  {
    def makeDist( trxCount: int, quantums: int ) : List[ int ] =
      {
        def nextValue( values: List[ int ],
            remainingTrx: int,
            remainingQuantums: int ) : List[ int ] =
            {
              val r = Math.round(remainingTrx.toFloat / remainingQuantums) :: values
              if( remainingQuantums > 1 )
                nextValue( r, remainingTrx - r.head, remainingQuantums - 1 )
              else r
            }

        nextValue( Nil, trxCount, quantums ).reverse
      }

    def main( args: Array[ String ] ) =
      {
        val d = makeDist( 2, 6 )
        for( val i <- d )
          System.out.print( i + "," )
      }
  }

import std.stdio;

int delegate(int) test(int x)
{
return (int y) {return x + y;};    
}

void main()
{
writefln(test(123)(1));
writefln(test(10)(10));
}

#pragma indent

using System.Console
using System.Math

def makeDistrib(trxCount : int, quantums : int)
    mutable r : list[int] = []
    mutable remainingTrx = trxCount
    mutable remainingQuantums = quantums
    foreach (_i in [1..quantums])
        r ::= Round(remainingTrx / (remainingQuantums :> double)) :> int
        remainingTrx -= r.Head
        --remainingQuantums
    r

def r = makeDistrib(2, 6)
WriteLine($"$r")

  macro RealCurry (func)
  {
    def typer = Macros.ImplicitCTX ();
    def smtype = typer.TypeExpr (func).Type.Hint;
    match (smtype)
    {
      | Some (MType.Fun as mtype) => 
        match (mtype.from)
        {
          | MType.Tuple (args) => 
            def makeCurryFunction (argCount, argNames)
            {
              if (argCount == 0)
                <[ $func(.. $argNames) ]>
              else
              {
                def x = Macros.NewSymbol ();
                def pe = <[ $(x : name) ]>;
                <[ ($pe) => { $(makeCurryFunction (argCount-1, argNames + [pe])) } ]>
              }
            }
            makeCurryFunction(args.Length, []);
          | MType.Class => 
            <[ $func ]>
          | MType.Void => 
            Message.FatalError (func.Location, $"`$func' should have at least one parameter.");
          | _ => 
            Message.FatalError (func.Location, $"Hmmm... Some strange arguments...");
        }
      | _ => Message.FatalError (func.Location, $"`$func' should be a function.");
    }
  }

  module RealCurryTest
  {
    public Run () : void
    {
      def plus = (x, y, z) => { x + y + z };
      def cplus = RealCurry(plus);
      WriteLine(cplus(1)(2)(3));

      def mult = (x, y, z) => { x + y * z };
      def cmult = RealCurry(mult);
      WriteLine(cmult(1)(2)(3));
    }
  }

E>А без #pragma indent? (просто регулярно всплывают проблемы из-за табуляций/пробелов).

[1, 0, 1, 0, 0, 0]

WriteLine(r.ToString(", "))

ie>#pragma indent

ie>using System.Console
ie>using System.Math

ie>def makeDistrib(trxCount : int, quantums : int)
ie>    mutable r : list[int] = []
ie>    mutable remainingTrx = trxCount
ie>    mutable remainingQuantums = quantums
ie>    foreach (_i in [1..quantums])
ie>        r ::= Round(remainingTrx / (remainingQuantums :> double)) :> int
ie>        remainingTrx -= r.Head
ie>        --remainingQuantums
ie>    r

ie>def r = makeDistrib(2, 6)
ie>WriteLine($"$r")
ie>

[1, 0, 1, 0, 0, 0]

0,0,1,0,1,0

double x0 = Math.Round(0.5);  // x0 == 0.0
double x1 = Math.Round(0.5, MidpointRounding.AwayFromZero);  // x1 == 1.0

ie>Угу, тут в примерах это хорошо видно. — почему такое поведение. Как-то, по-моему, в .NET эта тема поднималась, но к чему пришли не помню, лень искать

ie>+1 забыл

#pragma indent
 
using System.Console
using System.Math
 
def makeDistrib(trxCount : int, quantums : int)
    mutable r : list[int] = []
    mutable remainingTrx = trxCount
    mutable remainingQuantums = quantums
    foreach (_i in [1..quantums])
        r ::= Round((remainingTrx :> double) / remainingQuantums + 0.1) :> int
        remainingTrx -= r.Head
        --remainingQuantums
    r = r.Reverse
    r
 
def r = makeDistrib(2, 6)
WriteLine($"$r")

E>Опытным путем удалось установить, что достаточно прибавлять 0.1, тогда округляет как нужно. Но вот как сделать реверсию я не догнал

def makeDistrib(trxCount, quantums : int)
  mutable r = []
  mutable remainingTrx = trxCount
  mutable remainingQuantums = quantums
  foreach (_i in [1..quantums])
    // как правильно сказал Oyster
    r ::= Round(remainingTrx / (remainingQuantums :> double), 
                MidpointRounding.AwayFromZero) :> int
    remainingTrx -= r.Head
    --remainingQuantums
  r.Rev()

E>А без #pragma indent? (просто регулярно всплывают проблемы из-за табуляций/пробелов).

using System.Console
using System.Math

def makeDistrib(trxCount : int, quantums : int)
{
    mutable r : list[int] = []
    mutable remainingTrx = trxCount
    mutable remainingQuantums = quantums
    foreach (_i in [1..quantums])
    {
        r ::= Round(remainingTrx / (remainingQuantums :> double)) :> int
        remainingTrx -= r.Head
        --remainingQuantums
    }
    r
}

def r = makeDistrib(2, 6)
WriteLine($"$r")

E>А к функциональности еще привыкать нужно (например, необходимость вызова reverse после возврата из nextValue не слишком очевидна). Ну и под Scala все переписывать нужно

def make_dist(trx_count, quantum_count, result = []):
    if quantum_count == 0: 
        return result
    else:
        result.append(int(round(float(trx_count) / quantum_count)))
        return make_dist(trx_count - result[-1], quantum_count - 1, result)

print ", ".join(map(str, make_dist(2, 6)))

def makeDistrib(trxCount : int, quantums : int)
{
| (_, 0) => []
| (remainingTrx, remainingQuantums) =>
    def r = (remainingTrx :> double) / remainingQuantums;
    def r = Round(r, MidpointRounding.AwayFromZero) :> int;
    r :: makeDistrib(remainingTrx - r, remainingQuantums - 1);
}
def r = makeDistrib(2, 6);
WriteLine($"$r");

auto test = new Testing(1, 2, 3);

E>>А к функциональности еще привыкать нужно (например, необходимость вызова reverse после возврата из nextValue не слишком очевидна). Ну и под Scala все переписывать нужно

import std.math;
import std.stdio;

int[] makeDistrib2(int trxCount, int quantums,  int[] result = [])
{
if(quantums == 0) return result;

auto next = cast(int)round(cast(float)trxCount / quantums);
return makeDistrib2(trxCount - next, quantums - 1, result ~ [next]);
}

void main()
{
writefln(makeDistrib2( 2, 6 ));
}

WH>А D? К тому же опять сколько времени делают немерле и сколько D? Я вот про D узнал за несколько лет до того как первый раз услышал про немерле. И еще учти что немерле горазо технологичнее чем D (один вывод типов чего стоит), а технологии требуют исследований. В тоже время в D нет вобще ничего скольнибудь не тривиального.

import std.math;
import std.stdio;

int[] makeDistrib(int trxCount, int quantums)
{
if(quantums == 0) return [];

auto next = cast(int)round(cast(float)trxCount / quantums);
return [next] ~ makeDistrib(trxCount - next, quantums - 1);
}

void main()
{
writefln(makeDistrib(2, 6));
}

WH>def makeDistrib(trxCount : int, quantums : int)
WH>{
WH>| (_, 0) => []
WH>| (remainingTrx, remainingQuantums) =>
WH>    def r = (remainingTrx :> double) / remainingQuantums;
WH>    def r = Round(r, MidpointRounding.AwayFromZero) :> int;
WH>    r :: makeDistrib(remainingTrx - r, remainingQuantums - 1);
WH>}
WH>def r = makeDistrib(2, 6);
WH>WriteLine($"$r");
WH>

object BufferizationDisturb extends Application {
  def makeDist(trxCount: int, quantum: int): List[int] = quantum match {
      case 0 => Nil
      case _ => {
        import java.lang.Math;
        val put = Math.round(trxCount.toFloat / quantum)
        put :: makeDist(trxCount - put, quantum - 1);
      }
    }
  val d = makeDist(2, 6)
  Console.println(d.mkString("", ", ", ""));
}

WH>def makeDistrib(trxCount : int, quantums : int)
WH>{
WH>| (_, 0) => []
WH>| (remainingTrx, remainingQuantums) =>
WH>    def r = (remainingTrx :> double) / remainingQuantums;
WH>    def r = Round(r, MidpointRounding.AwayFromZero) :> int;
WH>    r :: makeDistrib(remainingTrx - r, remainingQuantums - 1);
WH>}
WH>def r = makeDistrib(2, 6);
WH>WriteLine($"$r");
WH>

object BufferizatorDistrib4
  {
    def makeDist( trxCount: int, quantums: int ) : List[ int ] =
      quantums match
      {
        case 0 => Nil
        case _ =>
              val r = Math.round(trxCount.toFloat / quantums)
              r :: makeDist( trxCount - r, quantums - 1 )
      }

    def main( args: Array[ String ] ) =
      {
        System.out.print( makeDist( 2, 6 ) )
      }
  }

From: Avi Bryant (Nov 12 2006, at 16:04)

So I was curious just how much better those mythical Smalltalk VMs did at array indexing, and ran some quick benchmarks. In all cases what I was measuring was the time it took to do one billion accesses of a 1000 element array of integers in the 0..255 range, discounting loop overhead and startup time. This is on my MacBook Pro; Ruby, Squeak and Java are running natively, Strongtalk is in Windows inside Parallels so probably slightly penalized. Here's what I got; for some reason the top three fall neatly into a 10x progression.

Java: 0.7s

Strongtalk Smalltalk: 7.0s

Squeak Smalltalk: 70s

Ruby: 200s

Java is definitely the winner, which shouldn't be that surprising given that it has a primitive char type whereas everyone else is working with tagged integers. The other three are a "fair" comparison, in that the languages are all equally dynamic, open classes, objects all the way down, yadda yadda. Except that it's not fair, because the Strongtalk VM just cleans the floor with the other two. And (as I always feel compelled to point out) Ruby could run on this VM with 0 performance penalty, completely unlike JRuby, Ruby.NET, and so on.

So, Tim, want RX to run 30x faster? Let's get Ruby running on Strongtalk.

G>Обогнал

G>object BufferizationDisturb extends Application {
G>  def makeDist(trxCount: int, quantum: int): List[int] = quantum match {
G>      case 0 => Nil
G>      case _ => {
G>        import java.lang.Math;
G>        val put = Math.round(trxCount.toFloat / quantum)
G>        put :: makeDist(trxCount - put, quantum - 1);
G>      }
G>    }
G>  val d = makeDist(2, 6)
G>  Console.println(d.mkString("", ", ", ""));
G>}
G>

G>Но все равно на строчку меньше чем Руби

def make_dist(trx_count, quantum_count)
  return [] if 0 == quantum_count
  r = (trx_count.to_f / quantum_count).round
  [ r ] + make_dist( trx_count - r, quantum_count - 1 )
end

r = make_dist( 2, 6 )
puts r.join(',')

FR>import std.stdio;

FR>int delegate(int) test(int x)
FR>{
FR>return (int y) {return x + y;};    
FR>}

FR>void main()
FR>{
FR>writefln(test(123)(1));
FR>writefln(test(10)(10));
FR>}
FR>

FR>Кто нибудь в курсе это так, или случайные совпадения , а то я в документации про замыкания ничего ни нашел.

When comparing with nested functions, the function form is analogous to static or non-nested functions, and the delegate form is analogous to non-static nested functions. In other words, [b]a delegate literal can access stack variables in its enclosing function[/url], a function literal cannot.

либо совершенно иная нежели CLR и JavaVM виртуальная машина.

makeDist _ 0 = []
makeDist n m = let r = round (fromIntegral n / m) in r : makeDist (n-r) (m-1)
main = show (makeDist 2 6)

ie>Точно-точно!

ie>makeDist _ 0 = []
ie>makeDist n m = let r = round (fromIntegral n / m) in r : makeDist (n-r) (m-1)
ie>

def makeDist(n, m)
    if (n == 0) [] else
        def r = (n / m:>double).Round():>int; r :: makeDist(n-r, m-1)

module RoundExt
    public Round(this num : double, mode : MidpointRounding = MidpointRounding.AwayFromZero) : double
        System.Math.Round(num, mode)

import functools.partial

def plus(x, y, z):
    return x + y + z

def minus(x, y, z):
    return x - y - z

plus_two = partial(plus,2);
print plus_two(6, 8)

plus_three = partial(plus_two,3);
print plus_three(7)

plus_all = partial(partial(partial(plus,3),4),5); # видимо только так?
print plus_all()

minus_all = partial(partial(partial(minus,7),8),9);
print minus_all()

FR>Не это не то просто function считается статическим и соответствено не может ссылатся на локальные переменные, delegate же может. Но для delegate там ниже написано что нельзя ссылатся на локальные переменные из вложенной функции, так как при выходе получим мусор указывающий на стек, я попробовал на простых примерах все почему-то работает, вот и гадаю теперь UB или не UB Ладно надо будет примерчик посложнее проверить.

import std.stdio;

void main()
{
  int delegate(int) test(int x)
  {
    return (int y) {return x + y;};    
  }
  
  writefln(test(1)(2));
}

import std.math;
import std.stdio;

int[] makeDistrib2(int trxCount, int quantums,  int[] result = [])
{
  return (quantums == 0) ?
      result
    : { auto next = cast(int)round(cast(float)trxCount / quantums);
        return makeDistrib2(trxCount - next, quantums - 1, result ~ [next]); }() ;
}

void main()
{
  writefln(makeDistrib2( 2, 6 ));
}

C# on .NET 2.0 : 1.902 sec
DMD 0.173 — malloc(original version) : 5.189 sec
C# on Mono 1.1.18 : 6.630 sec
DMD 0.173 — full GC : 19.720 sec

АХ>Хаскель не знаю

def plus(x, y, z): return x + y + z

def minus(x, y, z): return x - y - z

plus_two = lambda y, z: plus(2, y, z)
print plus_two(6, 8)

plus_three = lambda y: plus_two(3, y)
print  plus_three(7)
    
plus_all = lambda: plus(7,8,9)
print plus_all()

minus_all = lambda: minus(7, 8, 9)
print minus_all()

E>Опытным путем удалось установить, что достаточно прибавлять 0.1, тогда округляет как нужно. Но вот как сделать реверсию я не догнал

#pragma indent
 
using System.Console
using System.Math
 
def makeDistrib(trxCount : int, quantums : int)
    mutable r = Collections.Generic.List()
    mutable remainingTrx = trxCount
    mutable remainingQuantums = quantums
    foreach (_ in [1..quantums])
                def x = Round((remainingTrx :> double) / remainingQuantums + 0.1) :> int
        r.Add(x)
        remainingTrx -= x
        --remainingQuantums
    r
 
WriteLine(makeDistrib(2, 6).ToString(", "))

VD>А чё бы не поглумиться нед теми кто прославляет убогсть только потому, что она чуть мнее убогая чем старая убогсть?

   - Писсант - это такой тип, который воображает, будто он умнее
всех, и потому никогда не промолчит. Чтобы другие  ни  говорили,
писсанту  всегда  надо  спорить.  Вы скажете,  что  вам   что-то
нравится, и, клянусь богом, он тут же начнет вам доказывать, что
вы не правы и это вам нравиться не должно. При таком писсанте вы
чувствуете себя окончательным болваном. Что бы вы ни сказали, он
все знает лучше вас.

Мощь языка, в которой заинтересован программист, возможно, трудно определить формальными методами, однако одно из объяснений этого понятия заключается в свойствах, которые в менее мощном языке можно получить, только написав на нем интерпретатор для более мощного языка.