Difference between revisions of "Function literals"

From D Wiki
Jump to: navigation, search
(Expand)
m (fix syntax error)
 
(2 intermediate revisions by one other user not shown)
Line 5: Line 5:
 
For example:
 
For example:
 
<syntaxhighlight lang="D">
 
<syntaxhighlight lang="D">
  int function(char c) fp;
+
int function(char c) fp;
  void main()
+
 
  {
+
void main()
    static int foo(char c) { return 6; }
+
{
    fp = &foo;
+
  static int foo(char c) { return 6; }
  }
+
  fp = &foo;
 +
}
 
</syntaxhighlight>
 
</syntaxhighlight>
  
Line 16: Line 17:
  
 
<syntaxhighlight lang="D">
 
<syntaxhighlight lang="D">
  int function(char c) fp;
+
int function(char c) fp;
  void main()
+
 
  {
+
void main()
    fp = function int(char c) { return 6;}; //note the semi-colon at the end
+
{
  }
+
  fp = function int(char c) { return 6;}; //note the semi-colon at the end
 +
}
 
</syntaxhighlight>
 
</syntaxhighlight>
  
Line 42: Line 44:
  
 
     // Verbose syntax
 
     // Verbose syntax
     dg = delegate(int x) { return arg * x; }
+
     dg = delegate(int x) { return arg * x; };
  
 
     // Lambda syntax
 
     // Lambda syntax
Line 59: Line 61:
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
[[Category:HowTo]]

Latest revision as of 13:26, 26 August 2017

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
}