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