<T, U, V> T->U->V curry((T,U)->V func) = T parm1 => U parm2 => func(parm1, parm2);
void main(String[] args) = println(curry((int a, int b) => a + b)(2)(2));

Encountered ", b ) =>".
Was expecting one of:
    "->" ...
    "?" ...
    <IDENT> ...
    "[]" ...
    "[?]" ...
    "." ...
    "<" ...
    "," "?" ...
    "," "!" ...
    "," "(" ...
    "," "alike" ...
    "," <IDENT> "." ...
    "," <IDENT> "<" ...
    "," <IDENT> "[]" ...
    "," <IDENT> "[?]" ...
    "," <IDENT> "?" ...
    "," <IDENT> "->" ...
    "," <IDENT> "," ...
    "," <IDENT> ")" "?" ...
    "," <IDENT> ")" "->" ...
    "," <IDENT> ")" "[]" ...
    "," <IDENT> ")" "[?]" ...
    "," <IDENT> ")" <IDENT> ...
    "(" ...
    ">" ...
    "," <IDENT> "(" ...
    "," <IDENT> <IDENT> ...
    "," <IDENT> ">" ...
    "," <IDENT> "!" ...
    "," <IDENT> "alike" ...
    "," <IDENT> ")" "=>" ...

compilation failed with 1 error

E>import std.stdio;

E>V delegate(U) delegate(T) curry(T, U, V)( V delegate(T, U) func )
E>  {
E>    return (T a) { return (U b) { return func(a, b); }; };
E>  }

E>void main()
E>  {
E>    int x = curry( ( int a, int b ) { return a + b; } )( 3 )( 2 );
E>    writefln( "x=", x );
E>  }
E>

 V finalResult( U b )
    {
        return func( a, b );
    }
return finalResult;

return &finalResult;

E>class Demo {
E>    int f() { return 0; }
E>    int demo() { return f; }
E>}
E>

E>class Demo {
E>    int f() { return 0; }
E>    int demo() { return f; }
E>}
E>

E>class Demo {
E>    int f() { return 0; }
E>    int demo() { return this.f; }
E>}
E>

E>void demo() {
E>  void endl() { writefln; }
E>  endl;
E>}
E>

E>void demo() {
E>  void endl() { println(); }
E>  endl;
E>}
E>

<T, U, V> T->U->V curry((T,U)->V func) = T parm1 => U parm2 => func(parm1, parm2);

void main(String[] args) = println(curry((int a, int b) => a + b)(2)(2));

C:\Nice>nicec -a curry.jar curry
nice.lang: parsing
curry: parsing
curry: typechecking
curry: generating code
curry: linking
curry: writing in archive
nice.lang: writing in archive

C:\Nice>java -jar curry.jar
4

void foo (int -> int & fun_ref)
{
  fun_ref << (x){ assert(x > 0); } // добавили новый код в начало - проверка параметра
}

int my (int x) { return x - 10; } // объявили новую функцию

void test()
{
  foo (my); // изменили ее
  my (-10); // ошибка!
}

int const x = 5;
int my_x (int x) { return x - 10; } // константная функция
int y = 6; // мутабельный объект
int -> int my_y = (x){return x - 10;} // мутабельная функция

#include <iostream>

int f(int x) { return x + 1; }

int main()
{
  int (&my)(int) = f;
  std::cout << my(5);
}

import std.stdio;

V delegate(U) delegate(T) curry(T, U, V)( V delegate(T, U) func )
  {
    V delegate(U) intermediateResult( T a )
      {
        V finalResult( U b )
          {
            return func( a, b );
          }
        return &finalResult;
      }

    return &intermediateResult;
  }

void main()
  {
    int x = curry( delegate int( int a, int b ) { return a + b; } )( 3 )( 2 );
    writefln( "x=", x );
  }

// vim:ts=2:sts=2:sw=2:expandtab

K>>><T, U, V> T->U->V curry((T,U)->V func) = T parm1 => U parm2 => func(parm1, parm2);

K>>>void main(String[] args) = println(curry((int a, int b) => a + b)(2)(2)); 
K>>>

E>>Ну а паттерн-матчинг где?

let x = if( a ) b else c

void
readLines( boolean showGoodMessages )
  {
    let stdin = new BufferedReader( new InputStreamReader( System.in ) );
    void readAndProcessLine( String line )
      {
        if( line != null )
          {
            parseLine( line, showGoodMessages );
            readAndProcessLine( readLine( stdin ) );
          }
      }
    readAndProcessLine( readLine( stdin ) );
  }

void
readLines( boolean showGoodMessages )
  {
    let stdin = new BufferedReader( new InputStreamReader( System.in ) );
    var line = readLine( stdin );
    while( line != null )
      {
        parseLine( line, showGoodMessages );
        line = readLine( stdin );
      }
  }

class point =
  object
    val pos = 0
    method get = pos
    method set pos’ = {< pos = pos’ >}
  end;;

something( producer.demo )

something( agent producer.demo )

Перечисление набора языков, раз за разом — это контрпродуктивно на мой взгляд. Например потому, что принадлежность языков из этого списка к (не) функциональным как бы сама собой разумеется, но на самом деле ниоткуда не следует.

interface IAgent<T, U, V>
{
    V call(T a, U b);
}

// C# 1.0 - делегат создается явно
FuncType fvalue = new FuncType(Function);
// функция - гражданин второго сорта. Она унижена и прищемлена.

// С# 2.0 - делегат создается неявно
FuncType fvalue = Function;
// справедливость торжествует!

// представляем анонимный метод(тм)!
FuncType fvalue = delegate(){return "я уродлив, но свое дело делаю";};

class
  AGENT_PROVIDER
feature
  demo (i: INTEGER; s: STRING) is
    do
        -- тут что-то происходит
    end
end

class
  AGENT_CONSUMER
feature
  call_agent (a: PROCEDURE [ANY, TUPLE [INTEGER, STRING]]) is
    do
    -- хорошо видно, что агент это вовсе не функция - это класс
    -- с методом call
      a.call ( [0, "Hello, World"] )
    end
end

class
  APPLICATION
create
  make
feature
  make is
    local
      producer: AGENT_PROVIDER
      consumer: AGENT_CONSUMER
    do
      create producer
      create consumer
    -- а здесь мы наблюдаем, как функция (а точнее - метод) producer.demo
    -- явным образом оборачивается в класс - агент,
    -- становясь методом call этого класса.
      consumer.call_agent (agent producer.demo)
    end
end

Существует так же возможность создавать т.н. inline agents, т.е. агентов тело которых определяется непосредственно в конструкции agent:

consumer.call_agent (
    agent (i: INTEGER; s: STRING) do io.put_string ("inline agent!%N") end)

void f( A b ) { ... }

void f( ()->A b ) { ... }

E>void f( A b ) { ... }
E>

E>void f( ()->A b ) { ... }
E>

curry(foo);

curry(agent foo);

consumer.call_agent (producer.demo)

consumer.call_agent (agent producer.demo)

io.put_string (s) -- s - переменная, содержащая строку.

E>>void f( A b ) { ... }
E>>

E>>void f( ()->A b ) { ... }
E>>

K>curry(foo);
K>

K>curry(agent foo);
K>

K>consumer.call_agent (producer.demo)
K>

K>consumer.call_agent (agent producer.demo)
K>

K>io.put_string (s) -- s - переменная, содержащая строку.
K>

local
  a: <тип агента>
do
  a = agent producer.demo
  -- то вы можете написать так же, как и с переменной s.
  consumer.call_agent (a)
end

E>something( producer.demo )
E>

E>something( agent producer.demo )
E>

Разве только автор считал удобным синтаксически подчеркнуть разницу — а это прямое указание на то, что первоклассность функций считается в этом языке нежелательной возможностью.

//Есть HOF без параметров, возвращающая функцию a -> b. 
//Т.е. тип функционального значения для нее () -> (a -> b)

foo : a -> b
{
    //...
}

//Имеем функцию высшего порядка

bar1(a : () -> (a -> b))
{
    //...
}

bar1(foo) // передаем в bar1 функциональное значение.

//Имеем функцию высшего порядка

bar2(a : a -> b)
{
    //...
}

bar2(foo) // вызываем foo и передаем в bar2 результат.

K>//Есть HOF без параметров, возвращающая функцию a -> b. 
K>//Т.е. тип функционального значения для нее () -> (a -> b)

K>foo : a -> b
K>{
K>    //...
K>}

K>//Имеем функцию высшего порядка

K>bar1(a : () -> (a -> b))
K>{
K>    //...
K>}

K>bar1(foo) // передаем в bar1 функциональное значение.
K>

_ = foo

consumer.call_agent (
    agent () do io.put_string (X) end)
E>

consumer.call_agent (
   agent (i: INTEGER; s: STRING) do io.put_string ("inline agent!%N") end)

consumer((_, _) => io.put_string ("inline agent!%N"));

LAGE: What are Eiffel agents?

In the early years of Eiffel, the language had no routine types
because having routines as distinct entities outside objects
was seen as incompatible with the OO method.

Nevertheless, it has now been accepted that routines as first
class objects are essential and the 'agents' facility has been
introduced. It has been implemented at least in part in Eiffel
Software's compiler and SmartEiffel. Other active vendors are
likely to follow.

While this feature is new and the standard is being finalised,
the core concepts, routine types and tuples for representing
the parameters and return type of a routine, are now well
understood.

An ordinary agent is created within the current object,
which provides a context and makes the facility as expressive as
higher order functions (closures) in functional programming
languages.

E>>_ = foo
E>>

void f()
  {
    A b(C);
  }

E>Так я и не могу понять, откуда же следует этот вывод.

foo()
f = foo
f()

foo()
а = agent foo
a.call()

K>foo()
K>f = foo
K>f()
K>

K>foo()
K>а = agent foo
K>a.call()
K>

(define (foo)...)
(set! f  foo)
(f)

(defun foo ()...)
(setq f  (function foo))
(funcall f)

foo(bar)

bar.foo()

K>>>foo(bar)
K>>>bar.foo()
K>>>

void main( String[] args )
  {
    let f = () => println( "Hello!" );
    let g = f;
    println( "g and f are: " + ( g == f ? "same" : "different" ) );
    println( f.getClass().getName() );
  }

gnu.expr.ModuleMethod
g and f are: same

E>Так что, D уже функциональным языком стал?

Ну значит стал — не вижу в этом ничего сенсационного. Было бы странно, если бы язык, разрабатываемый в 2000-х годах им не стал.

А пример, приведенный вашему, можно и на D 2.0 изобразить, там уже замыкания есть. Так что, D уже функциональным языком стал?

E>А пример, приведенный вашему, можно и на D 2.0 изобразить, там уже замыкания есть.

И как это будет выглядеть?

E>Так что, D уже функциональным языком стал?

Ну значит стал — не вижу в этом ничего сенсационного.

(список аргументов)->тип результата

тип результата delegate(список аргументов)

T p => D

(T p) => { return D; }

(T p) { return D; }

delegate V(T p) { return D; }

(T p)->V => { return D; }
// или же
(T p)->V => D

<T, U, V> T->U->V curry((T,U)->V func) = T parm1 => U parm2 => func(parm1, parm2);

<T, U, V>
T->(U->V) curry((T,U)->V func) {
    return (T parm1) => {
        return (U parm2) => {
            return func(parm1, parm2); }; };
}

import std.stdio;

V delegate(U) delegate(T) curry(T, U, V)( V delegate(T, U) func )
  {
    return (T a) { return (U b) { return func(a, b); }; };
  }

void main()
  {
    int x = curry( ( int a, int b ) { return a + b; } )( 3 )( 2 );
    writefln( "x=", x );
  }

V delegate(U) delegate(T)

T->(U->V)

V delegate(T, U) func

(T, U)->V func

int->int demo()
    {
        int inc( int a ) = a + 1;
        return inc;
    }

int delegate(int) demo()
    {
        int inc( int a ) { return a + 1; }
        return &inc;
    }

class Demo {
    int f() { return 0; }
    int demo() { return f; }
}

class Demo {
    int f() { return 0; }
    int demo() { return f; }
}

class Demo {
    int f() { return 0; }
    int demo() { return this.f; }
}

void demo() {
  void endl() { writefln; }
  endl;
}

void demo() {
  void endl() { println(); }
  endl;
}

E>void main( String[] args )
E>  {
E>    let f = () => println( "Hello!" );
E>    let g = f;
E>    println( "g and f are: " + ( g == f ? "same" : "different" ) );
E>    println( f.getClass().getName() );
E>  }
E>

E>gnu.expr.ModuleMethod
E>g and f are: same
E>

void foo () { println("Hello!"); }

void main (String[] args)
{
  println (foo.getClass().getName() );
}

let f = () => println("Hello!");