# Lambda expressions · Chromia Docs (concept)

> A lambda expression is an anonymous function written with arrow syntax (->).

Source: https://docs.chromia.com/rell/language-features/expressions/lambda-expressions/

# Lambda expressions

On this page

* [Lambda body](#lambda-body)
* [Parameter types](#parameter-types)
* [Lambdas and standard library functions](#lambdas-and-standard-library-functions)
* [Variable capture](#variable-capture)

A lambda expression is an anonymous function written with arrow syntax (`->`). It evaluates to a first-class function
value, so you can store it in a variable, pass it to a function, return it from a function, and call it like any other
function value.

Rell

```
x -> x * 2                 // one parameter
(x, y) -> x + y            // parenthesized parameters
() -> 42                   // no parameters
```

## Lambda body

The body is either a single expression, or a value block whose trailing expression is the result:

Rell

```
val f: (integer) -> integer = n -> {
    val doubled = n * 2;
    doubled + 1
};
f(5);   // 11
```

`return` isn't allowed inside a lambda; the result is the final expression. For the general rules of value blocks, see
[Value block arms](https://docs.chromia.com/rell/language-features/expressions/conditional-expressions/#value-block-arms).

## Parameter types

A parameter's type comes from either an explicit annotation or the expected function type at the use site (target
typing). Annotations use the parenthesized form and are all-or-nothing: annotate every parameter or none. The return
type is always inferred from the body.

Rell

```
val f: (integer) -> integer = x -> x * 2;   // x is integer, from the declared type
f(10);                                      // 20

val g = (x: integer) -> x * 2;              // x is integer, from the annotation; g is (integer) -> integer
g(10);                                      // 20

function reduce(xs: list<integer>, f: (integer) -> integer): integer {
    var s = 0;
    for (x in xs) s += f(x);
    return s;
}

reduce([1, 2, 3], x -> x * x);              // 14
```

A lambda whose parameters are neither annotated nor typed by an expected function type is a compile error. A
parameterless lambda needs neither, because it has nothing to type.

## Lambdas and standard library functions

Lambdas fit the standard library functions that take a function value. For example, `join_to_text()` maps each element
through a function before joining it; combined with a named argument, a one-line lambda supplies that function without
spelling out the intervening optional parameters:

Rell

```
[1, 2, 3].join_to_text(transform = x -> "n" + x);   // "n1, n2, n3"
```

When the work needs several statements, a lambda with a value-block body replaces the
[partial application](https://docs.chromia.com/rell/language-features/modules/function/#partial-function-application) that was previously the
only option:

Rell

```
function checked_div(a: integer, b: integer): integer {
    require(b != 0, 'division by zero');
    return a / b;
}

val result = try_call(() -> {
    val h = checked_div(20, 4);
    h * h
});   // integer? - 25, or null if the call threw
print(result);   // 25
```

## Variable capture

A lambda captures each enclosing local variable it refers to by reading the binding's current value when the lambda is
created. Reassigning that outer variable afterwards isn't visible inside the lambda. This is a value capture in the same
sense as any Rell assignment, not a deep snapshot: a captured mutable object (a list, map, or set) is captured by its
reference, so an in-place mutation made to it after the lambda is created is visible inside the lambda. A captured
variable is read-only inside the lambda.

Rell

```
var n = 7;
val g: (integer) -> integer = x -> x + n;
n = 100;
g(1);   // 8 - reassigning n is not seen; g read n's value (7) when it was created

val xs = [1, 2, 3];
val h: () -> integer = () -> xs.size();
xs.add(4);
h();    // 4 - xs is captured by reference, so the in-place add IS seen
```

note

Lambda expressions are available from Rell 0.16.1.

[View this page on docs.chromia.com](https://docs.chromia.com/rell/language-features/expressions/lambda-expressions/)Content mirrored from the live docs
