There are couple things we can call in PHP: functions, methods and static methods. Version 5.3 introduced another two callables: closures and objects implementing __invoke() method.

In the previous post we used closures to implement Groovy-like array utilities. Today we’ll see how closures can be used to simplify function calls and how they (don’t?) fit into class-related constructs.

Unified calling convention

Depending on the function type, we use different syntax to invoke it. Let’s start with an example:

function regular_function($a1)
{
	echo __FUNCTION__  . "($a1)\n";
}

class SomeClass
{
	function regular_method($a1)
	{
		echo __METHOD__  . "($a1)\n";
	}

	static function static_method($a1)
	{
		echo __METHOD__  . "($a1)\n";
	}
}

$obj = new SomeClass;

To call these functions, we say:

regular_function(1);
$obj->regular_method(2);
MyClass::static_method(3);

This is basic stuff. But what if we don’t want to hard-code the function names? For instance, what if we want to switch static_method with dummy_method for testing purposes? One option is to use call_user_func_array function. But then we still need to check what are we calling (function, method or static method) and invoke call_user_func_array accordingly.

Another solution is to wrap the thing we want to call in a closure. Then we get this:

$c1 = to_closure('regular_function');
$c2 = to_closure('regular_method', $obj);
$c3 = to_closure('static_method', 'MyClass');

// same call syntax for all functions
$c1(1);
$c2(2);
$c3(3);

There is absolutely no difference between calling various types of functions. We can easily pass wrapped functions as parameters (for example, in a configuration file).

How do we implement to_closure function? It’s actually a simple call_user_func_array wrapper:

function to_closure($func_name, $class_or_object = null)
{
	$f = $class_or_object
		? array($class_or_object, $func_name)
		: $func_name;

	return function() use ($f) {
			return call_user_func_array($f, func_get_args());
		};
}

First we determine if given function is a method or a simple function. Then we just use created callable variable $f in the returned closure.

How is this useful? Think about it this way. Without closures, to achieve the same functionality, you’d probably wrap your function calls in classes. Perhaps three separate classes – for functions, for methods and for static methods. That’s certainly doable, but requires more code. So as usually, it’s all about simplicity (followed by ease of maintainability and modification).

Everywhere we’d use objects to wrap functions (even handling, factories, all kinds of callbacks etc.), we can use closures. How about using closures with classes?

JavaScript style functions? You wish!

This section shows how to use PHP closures in JavaScript way. If you know Ruby, Groovy, Scala or any other language with well implemented closures support, the code below will probably make you smile ;)

Let’s extend our class from the beginning of the article with the following method:

// a class member to be used in closures
var $x = 'this is SomeClass:$x';

public function member_closure_test() {
	// 1) alias $this so it can be accessed in closures
	$self = $this;

	// 2) JavaScript style
	$this->js1 = function() use ($self) {
		echo "JS simple $self->x\n";
	};
	// $this->js1() yields an error
	$f = $this->js1;
	$f();

	// 3) JavaScript style with the array wrapper trick
	$this->js2[0] = function() use ($self) {
		echo "JS with array $self->x\n";
	};
	$this->js2[0](); // For some reason, this works...
}

There are couple things to notice here:

1. We alias $this reference with local variable $self. That’s because we can’t use $this in use() declaration of a closure.
2. First attempt to create a JavaScript style function. We need to dereference the closure before calling it.
3. No temporary variables here. Undeclared arrays to the rescue!

Point 3) is the simplest solution I’ve come up with. As you can see, even with the array wrapper trick, we still need a temporary variable aliasing $this.

In conclusion

PHP wiki site considers using closures for extending classes a “common misconception”.
In other words, the “involved” syntax is not a bug – it’s a feature. Oh well, I don’t want to turn this blog into one big rant, so I’ll leave it at that ;)

On a positive note, closures provide new, more concise way to wrap function calls, which should reduce the number of objects floating around. They can also be used anywhere we’d use create_function before. And that’s definitely a good thing.

Source code for the article includes all presented examples.

So what’s the problem?

Say you select personal records from a database. You use left joins to connect the Person table with the Address table. You transform the results and put them in your data structures.

Now you want to display Joe’s home phone number. In Groovy, you do this:

contact_list?.get_contact("Joe")?.get_address("Home")?.phone

Short and NPE-proof.

So in PHP you’d like to do this:

$joes_home_phone = $contact_list
	->get_contact('Joe')
	->get_address('Home')
	->phone;

but because you don’t know if Joe has a home phone or if he even exists, you have to do this:

$joes_home_phone = "no home phone";
if (($t = $contact_list->get_contact('Joe')))
	if (($t = $t->get_address('Home')))
		$joes_home_phone = $t->phone;

Even though the code sample above is already shorter than a naive approach (we’ve cut some lines by using assignments inside the if conditions), it’s still obscured and tedious do write. What other options do we have?

How about the ternary operator?

One alternative to the code above would look like this:

$joes_home_number =	($t = $contact_list) ?
					($t = $t->get_contact('Joe')) ?
					($t = $t->get_address('Home')) ?
					$t->phone : null : null : null;

And here’s another option, using basic logical operators:

($t = $contact_list) &&
($t = $t->get_contact('Joe')) &&
($t = $t->get_address('Home')) &&
($t = $t->phone) || ($t = null);
$joes_home_number = $t;

It seems more concise and, and some people may find it more readable (especially the last example).

However, this is not what logical operators are for. Also if you’re the only programmer on your team, perhaps you could get away with this, but in a group environment this style of writing is usually banned. So that’s not the answer. What is then?

Other’s ideas, of course!

The solution presented below is inspired by Option class from Scala language. If you don’t know Scala, don’t worry. My PHP version of the idea is really simple, and uses couple basic PHP features.

Here’s how to use it:

// Function call chain
$joes_home_phone = Safe::make($contact_list)
	->get_contact('Joe')
	->get_address('Home')		// safe method call
	->phone						// safe field access
	->safe_get("no home phone");	// and dereference

// Array access chain
$joes_home_phone = Safe::make($contact_list)
	->contacts['Joe']
	->addresses['Home']			// safe array access
	->phone						// safe field access
	->safe_get("no home phone");	// and dereference

We can create longer call chains without any nesting or additional parentheses. The only extra code is at the beginning and at the end of the call chain. How does it work?

The idea here is to wrap result of every method call in a new Safe class instance. Because Safe class overrides the magic method __call(), we can handle cases where the invoked method returns null and allow further chaining.

Accessing fields is handled in a similar fashion. Custom array access relays on ArrayAccess interface implementation.

For another example, consider the following code:

class C1
{
	function method1() { return null; }
}

echo Safe::make(new C1)
	->method1()				// method1 returns null, but
	->nonexisting_field		// we can still safely do this
	->not_an_array[7]		// and this
	->safe_get("not found");

The code prints “not found” message.

Safe class implementation is rather short, so for more explanation just go ahead and look the the code.

Wrapping up

Of course, this solution is not a free lunch. As you probably guessed, the price for concise and flexible syntax is performance. Simple tests showed that it’s usually 5-8 times slower than piled-up if statements. However, often times PHP code is not a bottleneck (for example when you deal with a database) and for those cases, nicer and more concise code is worth more than a few CPU cycles.

Source code for this article contains complete implementation of the Safe class and some more extensive, ready to run usage examples.

Many languages provide nice and concise way of dealing with collections. This article presents “objectified” arrays implementation to demonstrate usage of closures in PHP 5.3.

Before we begin, please keep in mind that the code used is adjusted for educational purposes – performance aspects are not covered at all.

How others do it

Let’s start with a simple example. For the following array:

$nums = array(10, 20, 30, 40)

The task is to find all elements greater than 15.

So before without closures, we’d probably write something like this:

$res = array();
foreach ($nums as $n)
	if ($n > 15)
		$res[] = $n;

In languages with closures support, this could look more like this (Groovy):

def res = nums.findAll { it > 15 }

or like this (Scala)

val res = nums filter (_ > 15)

Notice how in Groovy and Scala we get pretty one-liners, because the looping part is abstracted away. With closures, we can do similar thing in PHP:

$res = array_filter($nums, function($v) { return $v > 15; });

We got almost twice as many characters with PHP as with Scala, but it’s still quite readable.

By the way, the PHP code above uses a lambda, not a closure, but the difference is not important right now. This site provides details on PHP closures and lambdas.

So far so good. Let’s consider another task: find all elements greater than 15 and multiply them by 2, and then add local variable x to each element.

Groovy:

def x = 1
def res = nums .findAll { it > 15 } .collect { it * 2 + x }

Scala:

val x = 1
val res = nums filter (_ > 15) map (_ * 2 + x)

and PHP:

$x = 1;
$res =
array_map(
	function($v) use ($x) { return $v * 2 + $x; },
	array_filter(
		$nums,
		function($v) { return $v > 15; })
);

Now that’s not even close to Groovy or Scala.

Aesthetics aside, there’s an additional problem with the code above. What if we wanted to filter array elements based on keys, and not values? Well, we can’t. At least not without some workarounds.

Imperative way of achieving the same thing would be as follows:

$x = 1;
$res = array();
foreach ($nums as $n)
	if ($n > 15)
		$res[] = $n * 2 + $x;

Perhaps it’s a bit cleaner, but when you see a code like this, you have to stop for a moment, before you actually see it: “ohh it’s just an array transformation”. So, let’s see how we can employ some rarely used PHP features to achieve something similar to what other languages have to offer.

ArrayObject – the array() wrapper

PHP comes with a standard library called SPL. One of the classes it provides is ArrayObject, which basically “allows objects to work as arrays”. For example

$res = new ArrayObject(array(10, 20, 30, 40));
foreach ($res as $v)
	echo "$v
";

Since ArrayObject is a built-in class, it can be extended like any other user-defined class.

Arr – wrapping the wrapper

Having ArrayObject class and closures at our disposal, we can start implementing our wrapper:

class Arr extends ArrayObject
{
	static function make($array)
	{
		return new self($array);
	}

	function map($func)
	{
		$res = new self();
		foreach ($this as $k => $v)
			$res[$k] = $func($k, $v);
		return $res;
	}

	function filter($func)
	{
		$res = new self();
		foreach ($this as $k => $v)
			if ($func($k, $v))
				$res[$k] = $v;
		return $res;
	}
}

Now the PHP solution for the second task discussed earlier could be rewritten as follows:

$res = Arr::make($nums)
	->filter(function($k, $v) { return $v > 15; })
	->map(function($k, $v) { return $v * 2; });

What’s the main difference here? First of all, the methods are chainable, so we don’t lose readability as we ad more filters or more complicated mapping. Also notice that the closures passed to filter and map take two parameters – key $k and value $v. This allows us to use key value in a closure, which is not possible with PHP standard array_filter function.

As a side effect we also get more consistent API. With native PHP functions, we sometimes pass the closure as a first argument, sometimes we pass the array first. Sometimes we even pass more than one array…

Source code for this article contains more complete version of the Arr class. Other useful functions (like reduce or walk) are implemented in a similar fashion.

Is it worth it?

I think there is no clear answer for this question – it all depends on the context and programmer’s preferences. When I first saw the syntax for PHP closures, I got a flashback from the old Java days, when I thought that anonymous inner classes could be used as closures. Well, they could, but it’s like putting a lipstick on a pig. PHP closures are not as bad, but the syntax is just plain ugly.

Other languages with closures support provide really nice syntax to use them. You can use regular loops in Scala as well, but why would you? Someone could say that you can use closures this way in PHP too, but why would you?

I’m sure closures will find their uses in the PHP world (like delayed execution or automated resource management), but IMHO replacing traditional loops and array operations is not one of them. Unless, at some point, they decide to break backwards compatibility and clean-up the syntax and API…

In conclusion

Like with most other language features added as an afterthought (remember Java generics? or not to look that far – PHP OOP?), it will take a while before closures gain wider attention. Meanwhile, since more and more web hosting providers introduce PHP 5.3 support and PHP 6 is on the way, it’s definitely a good idea to try out this new tool.

To answer the question from the beginning. If you compare this

$res = Arr::make($nums)
	->filter(function($k, $v) { return $v > 15; })
	->map(function($k, $v) { return $v * 2; });

to this

val res = nums filter (_ > 15) map (_ * 2)

the answer becomes clear: it’s the syntax, that’s what’s wrong.

I encourage you to download the source code for this article, where you can find more examples of how the functional approach to looping looks like in PHP.

There is, however, one feature (provided by some template engines), that makes managing complex sites easier.This feature is usually called “layouts”. By layout I mean something like master pages for ASP, Sitemesh for Java, or Django templates for Python.

This article presents a simple way to achieve similar functionality in PHP.

Features

The functionality we’re looking for:

• layout support, or template inheritance (to use Django terminology)
• easy way to define variables containing HTML
• default values for variables

And all this in less than 50 lines of code!

Implementation overview

Everything is wrapped in just one, easy to use class:

• Create new Template instance
• set name of the template to execute
• execute() and print the output

Full source code with examples is available for download, so I won’t paste it here. I’ll just explain some implementation details you may find interesting.

The execute() method includes the template, then checks if it defined a parent template. If so, the parent is included. If that parent also defined a parent, it is included as well, etc.

The only tricky part here is that the output from files included in execute() is buffered and stored in a special variable (called $body). If given template defines a parent template, that parent gets access to all variables available to the child, plus the output generated by the child – the $body.

The following piece of code explains the idea:

// execute the main template (probably in a controller if it's MVC)
echo Template::make('template1')->execute();

// which uses...
// template1.php
<?
	$this->extend('layout_main');
	$this->var_set($var1, 'template1 says hi');

// Everything returned below will be available in the
// extended template (layout_main) via $body
?>
This is cool!

// which uses...
// layout_main.php
<?
	$this->var_use($var1, 'default value for var1');
?>
<html>
	<body>
	<h1><?= $var1 ?></h1> // template1 says hi
	<?= $body ?> // This is cool!
	</body>
</html>

echo at the top prints

<html>
	<body>
	<h1>template1 says hi</h1>
	This is cool!
	</body>
</html>

Method chaining

Many Template methods return $this, so we can say:

echo Template::make()
	->name('template_x')
	->extend('layout_y')		// default layout
	->execute();

Very simple way to shorten the code.

Variable setting

There are two ways of setting variables for templates. First one is very simple:

// declaration
$tpl->var_set($greeting, 'Good morning');

// usage
echo "$greeting, stranger!";

var_set() method exploits one of the weird features of PHP, explained by the following example:

function f1($p) {}
f1($x); // Notice: Undefined variable: x

function f2(&$p) {}
f2($y); // Works

// Next two lines are equivalent to the line 5
$y = null;
f2($y);

The other way to define variables is a bit more involved:

// declaration
<? $this->var_begin($menu) ?>
	<ul>
		<li>uno</li>
		<li>dos</li>
	</ul>
<? $this->var_end() ?>

// usage
echo "The Spanish menu: $menu";

The trick here is to store the reference to the variable passed by reference. This allows var_end() method to assign a value to the variable passed to var_begin(). For those of you with C++ background, it works like Type*&amp; parameters in function parameters.

Of course, output buffering is used to grab everything between var_begin() and var_end().

Complex defaults

The function var_print() is a little helper that lets us to do this:

// some layout's markup...

// if the extending template didn't define custom menu,
// show the default one
<? if (!$this->var_print($menu)): ?>
	Default menu:
	<ul>
		<li>one</li>
		<li>two</li>
	</ul>
<? endif; ?>

// more markup...

This code simply prints the $menu variable if it’s defined. Otherwise it prints the default markup.

Wrapping up

Solution presented in this article is rather basic. It could be extended in many ways (with support for nested variables for example), but even this simple implementation provides enough functionality to build complex layouts.

Source code includes the Template class and usage examples.

So, that’s it for the first part. In the second installment of the series we’ll create the smallest usable dependency injection container :)

P.S. The main idea for this blog is to keep it simple. So, even if presented code may not always be very straight forward (although it should be), at least I’ll try to keep it short. This way it will be physically impossible to create anything too complicated :)