Function literals

Function Literals enable embedding anonymous functions directly into expressions.

Functions

For example:

  int function(char c) fp;
  void main()
  {
    static int foo(char c) { return 6; }
    fp = &foo;
  }

is exactly equivalent to:

  int function(char c) fp;
  void main()
  {
    fp = function int(char c) { return 6;}; //note the semi-colon at the end
  }

We now have anonymous functions...

This has brought up the specter of Dynamic Closures. The nested and/or anonymous functions can only access dynamic scope, which means scope that exists on the stack at the time of execution. This differs from lexical scope, which refers to the scope as indicated by the program text structure.

(More information can be found in the D Spec: Closures and Function Literals.)

Delegates

Delegates are "fat" function pointers that carry a context pointer with them. They can access local variables in scope at the time of their creation.

Syntax:

auto func(int arg)
{
    // A variable that can hold a delegate
    int delegate(int x) dg;

    // Verbose syntax
    dg = delegate(int x) { return arg * x; }

    // Lambda syntax
    dg = (x) => arg * x;

    return dg;
}

void main()
{
    auto dg1 = func(3);
    auto dg2 = func(5);

    writeln(dg1(2));   // prints 6
    writeln(dg2(2));   // prints 10
}