<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

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

<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

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

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

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

something( producer.demo )

something( agent producer.demo )

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 уже функциональным языком стал?

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

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

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

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

тип результата 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>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>

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

void demo() {
  let f = () => println();
}

void demo() {
  auto f = () { writefln(); };
}

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

void main( String[] args ) {
    println( "calling demo..." );
    demo();
    println( "converting demo to function reference..." );
    let f = demo;
    println( "calling demo via reference..." );
    f();
}

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 

package t2;


// Referenced classes of package t2:
//            fun

public class dispatch
{

    public static void main(String args[])
    {
        try
        {
            fun.main(args);
            return;
        }
        catch(Throwable uncaughtException)
        {
            nice.lang.dispatch.printStackTraceWithSourceInfo(uncaughtException);
        }
        System.exit(1);
    }

    public static void demo()
    {
        fun.demo();
    }

    public dispatch()
    {
    }
}
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 

package t2;

import gnu.expr.ModuleBody;
import gnu.expr.ModuleMethod;
import gnu.mapping.Procedure;
import nice.lang.dispatch;

// Referenced classes of package t2:
//            dispatch

public class fun extends ModuleBody
{

    public static void main(String args[])
    {
        dispatch.println("calling demo...");
        dispatch.demo();
        dispatch.println("converting demo to function reference...");
        Procedure f = demo;
        dispatch.println("calling demo via reference...");
        f.apply0();
    }

    public static void demo()
    {
        dispatch.println("Hello!");
    }

    public fun()
    {
    }

    public Object apply0(ModuleMethod modulemethod)
    {
        while(modulemethod.selector != 1) 
            throw new RuntimeException("bad case value!");
        dispatch.demo();
        return null;
    }

    public static final Procedure demo;
    public static final fun $instance;

    static 
    {
        $instance = new fun();
        demo = new ModuleMethod($instance, 1, "demo", 0);
    }
}

T delegate(T a) foo(T)()
{
    T Id(T a)
    {
        return a;
    }
    
    return &Id; // в случае с Id неопределенность между вызовом и возвратом функции была бы возможна, 
    // если бы Id была функцией без параметров, зачем здесь уточнение непонятно, ну да ладно.
}

T delegate(T a) foo(T)()
{
    T delegate(T) id = (T a){return a;};
    
    return id; // в случае с id неопределенность между вызовом и возвратом функции была бы возможна и т.д.
    // ВОПРОС: сработает ли это без & ? 
}

T delegate() foo(T)()
{
    T bar()
    {
        // ничего не делается
    }
    
    return &bar; // в случае с bar неопределенность между вызовом и возвратом функции.
}

T delegate(T a) foo(T)()
{
    T delegate(T) bar = T delegate(){return a;};
    
    return bar; // в случае с bar неопределенность между вызовом и возвратом функции.
    // ВОПРОС: сработает ли это без & ? 
}

T delegate(T a) foo1(T)()
{
    T Id(T a)
    {
        return a;
    }
    
    return &Id;
}


T delegate(T a) foo2(T)()
{
    T delegate(T) id = (T a) { return a; };
    
    return id;
}


T delegate() foo3(T)()
{
    T bar() { return T.init; }
    
    return &bar;
}


T delegate(T a) foo4(T)()
{
    T delegate(T) bar = delegate T(T a) { return a; };
    
    return bar;
}

void main()
{
    auto f1 = foo1!(int)();
    auto f2 = foo2!(int)();
    auto f3 = foo3!(int)();
    auto f4 = foo4!(int)();
}

agent my_object.some_method

new Agent { public void call() { myObject.some_method(); } };