At the PHP UK conference, I saw Sebastian Bergmann’s presentation on lambda functions, closures and traits. Lambda functions and closures are scheduled for 5.3 (or fivethree, as I’ve affectionately named the binary), or later. The presentation was intriguing, but has only simplistic examples, sufficient to illustrate the mechanical aspects. It left me curious as to what these features could be used for in real programs.

Before we start playing, let’s get the basic terminology clear. Lambda functions and closures are two fancy names for (variations on) anonymous functions. These are functions that are more flexible than ordinary functions and can be stored in variables or defined just where they are needed.

Anonymous functions are possible even in pre-5.3 PHP. They can be created using create_function(). But this is cumbersome, ugly, error-prone and possibly insecure. PHP 5.3 lets you do this in a much more natural and pleasant way.

The most basic and obvious case is sorting. Here is an example from Sebastian’s presentation:

<?php

usort(
    $list,
    function ($a, $b) {
        if ($a == $b) return 0;
        return ($a < $b) ? -1 : 1;
    }
);

In PHP before 5.3, this must be done either by using create_function() or by defining the function somewhere else, away from where it’s actually used. The above is clearly much better.

What else can we do with anonymous functions? In Ruby, they are the standard way of processing arrays. For example, if we want to process a set of files, adding a directory name at the beginning, we can do this:

files = ['pdo.a','pdo.la','pdo.so','sqlite.a','sqlite.la','sqlite.so'];
files_with_dir = files. map  { |f| "modules/#{f}" }

The snippet inside the braces is a function. map is the Ruby equivalent of PHP’s array_map(), except that Ruby is built to do this particular trick. But let’s try the equivalent with PHP 5.3. First we define the array:

$files = array('pdo.a','pdo.la','pdo.so','sqlite.a','sqlite.la','sqlite.so');

And then we process it:

$filesWithDir = array_map(
    function($f) { return "modules/$f" ; },
    $files
);

Interesting, but not necessarily better than the conventional alternative:

$filesWithDir = array();
foreach ($files as $file) {
    $filesWithDir[] = "modules/$file";
}

Using array_map() seems like a realistic option, at least for some cases. It reads differently because it’s conceptually different, focusing on processing the entire array rather than one element at a time. You might find it cleaner. And in some cases, it will be clearly superior. If you have a slightly more complex structure than a simple one-dimensional array, you can use array_map_recursive() to simplify the code dramatically.

In part 2, I’ll present an example of a JavaScript-style class composed of closures.