E>int inc( int a ) = a + 1;

E>void main( String[] args ) {
E>  let f = inc;
E>}
E>

E>class A {
E>  int inc( int a ) = a + 1;
E>}

E>void main( String[] args ) {
E>  let o = new A();
E>  let f = o.f; // вы, конечно, имели в виду o.inc
E>}
E>

class A {
  int inc(int a ) = a + 1;
}

void main( String[] args ) {
  let o = new A();
  let i = o.inc(1);
  let f = inc; // вот как это делается
  let j = f(o, 1);
  println(i == j);
}

K>>class A {
K>>  int inc(int a ) = a + 1;
K>>}

K>>void main( String[] args ) {
K>>  let o = new A();
K>>  let i = o.inc(1);
K>>  let f = inc; // вот как это делается
K>>  let j = f(o, 1);
K>>  println(i == j);
K>>}
K>>

class A {
  int inc(int a ) = a + 1;
}

class A {
}

int inc(A t, int a) = a + 1;

Delegates

There are no pointers-to-members in D, but a more useful concept called delegates are supported. Delegates are an aggregate of two pieces of data: an object reference and a function pointer. The object reference forms the this pointer when the function is called.

Delegates are declared similarly to function pointers, except that the keyword delegate takes the place of (*), and the identifier occurs afterwards:

int function(int) fp;    // fp is pointer to a function
int delegate(int) dg;    // dg is a delegate to a function

The C style syntax for declaring pointers to functions is also supported:

int (*fp)(int);        // fp is pointer to a function

A delegate is initialized analogously to function pointers:

int func(int);
fp = &func;        // fp points to func

class OB
{   int member(int);
}
OB o;
dg = &o.member;        // dg is a delegate to object o and
            // member function member

Delegates cannot be initialized with static member functions or non-member functions.

Delegates are called analogously to function pointers:

fp(3);        // call func(3)
dg(3);        // call o.member(3)

K>class A {
K>  int inc(int a ) = a + 1;
K>}
K>

K>class A {
K>}

K>int inc(A t, int a) = a + 1;
K>

class A { int inc(int a) = ... }
class B { int inc(int a) = ... }
int inc(int a) = ...;

class Demo { ... }
void f( Demo d ) {
  // d -- это ссылка на экземпляр Demo.
}
void g() {
  Demo o = new Demo; // o -- это ссылка на экземпляр Demo.
  f( o ); // Передача по ссылке.
}

E>class A { int inc(int a) = ... }
E>class B { int inc(int a) = ... }
E>int inc(int a) = ...;
E>

class A {
  int inc(int a ) = a + 1;
}

int inc(int a) = a + 1;

void main( String[] args ) {
  let o = new A();
  let i = o.inc(1);
  (A, int)->int f = inc;
  let j = f(o, 1);
  println(i == j);
}

И почему, внутри класса A метод inc имеет сигнатуру (int)->int, а вне -- (A,int)->int? Это, вообще-то говоря, разные функции.

K>class A {
K>  int inc(int a ) = a + 1;
K>}

K>int inc(int a) = a + 1;

K>void main( String[] args ) {
K>  let o = new A();
K>  let i = o.inc(1);
K>  (A, int)->int f = inc;
K>  let j = f(o, 1);
K>  println(i == j);
K>}
K>

// Первый файл.
package p1;

void serialize( String s, long l ) { ... }

// Второй файл.
package p2;

void serialize( String s, long l ) { ... }

// Третий файл.
import p1;
import p2;

void main( String[] args ) {
  (String, long)->void f = serialize;
}

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;} // мутабельная функция