Lambdas in C++0x, Part II

Let's recall the syntax of a lambda expression, from the first part of this post:

  [C](P) M -> R { body }(Q)

  C = capture specification
  P = parameter specification
  M = mutable specification
  R = return type specification
  Q = actual call parameters

Lambda expressions are locally defined functions, also known as anonymous functions. A minimal example could look something like this:

int main()
{
    auto f = []() { std::cout << "hello"; };
    f();
    return 0;
}

The lambda can also be invoked as it is defined, on-the-fly:

[]() { std::cout << "hello"; }();

Here is a lambda that takes an int as argument:

auto fn = [](int x) { std::cout << "x = " << x << "\n"; };
fn(123);

Side note: I tend to use the terms parameter and argument more or less interchangeably. To make things clear, we should, however, make a distinction between the two:

• A parameter is a variable declared in the prototype or declaration of a function.
• The argument is the value that is actually passed to the function.

A return value can be specified, using the trailing return type specification (→ R):

auto fn = [](int x) -> int { return x + 1; };
int n = fn(1);
std::cout << "->" << n << "\n";

The auto keyword saves us some work when the compiler is able to infer the type of an expression automatically. Alternatively, we could write:

std::tr1::function<int(int)> fn = [](int x) -> int { return x + 1; };

In this post, I will continue to examine the capture specification and mutable keyword.

Lambdas in C++0x, Part I

The new C++0x standard adds support for anonymous functions; so called lambda expressions. The concept of anonymous, or locally defined functions plays a central role in functional programming and has its origin in the Lambda Calculus (λ-Calculus); a theory formulated by Alonzo Church in 1936 (yes, that was before FORTRAN). The basic idea here is to treat functions as first class objects – functions can be stored in variables, passed as arguments, and be used as return values etc.

Lambda expressions are similar to functors (function objects), but with the added advantage of now being an integral part of the language. We can think of them as syntactic sugar for a functor. Just like function objects, lambdas are type-safe and can maintain state.

Using lambda expressions

The lambda term λx.3 represents the anonymous function x → 3, i.e., a function which takes a single input, x and (always) returns 3.

Using the new C++0x lambda syntax, this can be expressed as:

[](int x) { return 3; }

…where the initial square brackets ( [ ] ) are called the lambda introducer and tells the compiler that a lambda expression follows. Since x is irrelevant here, we may simply omit the parameter specification in this case. This leaves us with a very basic function that returns the value 3:

[] { return 3; }