PHP Arrow Functions: fn() => Syntax and Examples

An arrow function is a short anonymous function: fn($x) => $x * 2. The body after => is a single expression whose value is returned, and any variable from the surrounding code that the expression uses is captured automatically, by value. Arrow functions exist since PHP 7.4 and are mostly used as callbacks.

<?php
$double = fn($x) => $x * 2;
echo $double(21), "\n";

$prices = [10, 25, 40];
print_r(array_map(fn($p) => $p * 1.2, $prices));

$rate = 0.9;   // used inside without "use"
print_r(array_map(fn($p) => $p * $rate, $prices));

The syntax

fn, the parameter list, =>, one expression. Parameter types, default values and a return type work the same as in regular functions:

<?php
$add = fn(int $a, int $b = 1): int => $a + $b;
$greet = fn(string $name): string => "Hello, $name";
$isEven = fn(int $n): bool => $n % 2 === 0;
$now = fn() => 'no parameters';

echo $add(2, 3), ' ', $add(2), "\n";
echo $greet('Ada'), "\n";
var_dump($isEven(4), $isEven(7));
echo $now(), "\n";

// Call it immediately
echo (fn($x) => $x ** 2)(9), "\n";

There is no return keyword and no braces. A long expression can still be split over several lines for readability.

Outer variables are captured by value

An arrow function sees every variable of the scope where it is created. It copies their values at that moment. Changes made inside stay inside, and changes made outside after the function was created are not seen:

<?php
$count = 0;
$increment = fn() => ++$count;

echo $increment(), "\n";   // works on its own copy
echo $increment(), "\n";   // a fresh copy each call
echo $count, "\n";         // the outer variable is unchanged

$discount = 10;
$apply = fn($price) => $price - $discount;
$discount = 50;            // too late: 10 was already captured
echo $apply(100), "\n";

This is the main difference from function () use (&$count), which can share a variable by reference. An arrow function cannot reassign an outer variable. It can still change an object it captured (the copy is a handle to the same object), and a parameter declared by reference works as in any function: fn(array &$list) => $list[] = 'x'.

Callbacks for array_map, array_filter and usort

Most array functions take a callback, and that is where arrow functions save the most noise. Compare one filter written both ways:

<?php
$users = [
    ['name' => 'Ada', 'age' => 36, 'active' => true],
    ['name' => 'Linus', 'age' => 28, 'active' => false],
    ['name' => 'Grace', 'age' => 45, 'active' => true],
];

// Long form
$active1 = array_filter($users, function ($u) {
    return $u['active'];
});

// Arrow function
$active2 = array_filter($users, fn($u) => $u['active']);
var_dump($active1 === $active2);

$names = array_map(fn($u) => $u['name'], $active2);
echo implode(', ', $names), "\n";

usort($users, fn($a, $b) => $a['age'] <=> $b['age']);
echo implode(', ', array_column($users, 'name')), "\n";

$total = array_reduce($users, fn($sum, $u) => $sum + $u['age'], 0);
echo "Total age: $total\n";

<=> returns -1, 0 or 1, exactly what usort() wants, so sorting by a field fits on one line. Swap $a and $b to sort descending.

Arrow functions that return arrow functions

The captured variables include the parameters of an enclosing arrow function, so you can nest them to build functions from other values:

<?php
$multiplyBy = fn($factor) => fn($x) => $x * $factor;

$triple = $multiplyBy(3);
$tenTimes = $multiplyBy(10);

echo $triple(5), ' ', $tenTimes(5), "\n";

$between = fn($min, $max) => fn($n) => $n >= $min && $n <= $max;
$teen = $between(13, 19);
print_r(array_filter([8, 13, 16, 21, 19], $teen));

Note that array_filter() keeps the original keys, which is why the result starts at index 1.

fn vs function: when you need a full closure

Arrow functions stop working when the body needs more than one expression or must change an outer variable. Then use an anonymous function:

<?php
$orders = [120, 45, 300, 80];

// Needs a statement and an outer total: a closure with use (&...)
$total = 0;
$big = [];
array_walk($orders, function ($amount) use (&$total, &$big) {
    $total += $amount;
    if ($amount > 100) {
        $big[] = $amount;
    }
});
echo "Total $total, big orders: ", implode(', ', $big), "\n";

// The same result split into expressions: arrow functions fit again
$total2 = array_sum($orders);
$big2 = array_values(array_filter($orders, fn($a) => $a > 100));
echo "Total $total2, big orders: ", implode(', ', $big2), "\n";

When an arrow function feels cramped, it often means the job is two jobs. Splitting it into a filter and a sum, as above, keeps each callback a single expression.