If you are unfamiliar with promises, I suggest you read this article.  I borrowed the code for managing multiple promises from https://github.com/kriszyp/node-promise.  Essentially, we can use a promise to wrap many promises.  Only once the given set of promises are completely resolved does the wrapper promise resolve itself.  This is commonly called "all()".

var all = function(array){
    var deferred = $.Deferred();
    var fulfilled = 0, length = array.length;
    var results = [];
 
    if (length === 0) {
        deferred.resolve(results);
    } else {
        array.forEach(function(promise, i){
            $.when(promise()).then(function(value) {
                results[i] = value;
                fulfilled++;
                if(fulfilled === length){
                    deferred.resolve(results);
                }
            });
        });
    }
 
    return deferred.promise();
};

Looking at the implementation, the above function is pretty straightforward.  Let's look at an example on how to use it.

var users = ['john', 'ringo', 'paul', 'george'];
var promises = [];
 
users.forEach(function(user) {
    promises.push(function() {
        return $.Deferred(function(dfd) {
            $.get('/account/' + user, function(data) {
               dfd.resolve(data);
            });
        }).promise();
    });
});
 
$.when(all(promises)).then(function(results) {
    // do something with the results
});

The above example is making a series of requests for account information on a list of users.  Looping over the array of users, we push an anonymous function into an array call promises.  This anonymous function simply gives all() something to execute when call it.  We then wrap each ajax request in a promise  using $.Deferred().  We specify a callback that is the ajax request and then call promise() on $.Deferred.  The effect of this is that the all() function will iterate of the array of promises and execute each anonymous function.  The anonymous function returns the promise and the all() function keeps track of the state of each promise.  Once all the promises have been resolved, the all() function will resolve itself internal promise.  This allows use to use the all() function as single argument to $.when() that represents a set of promises we are expecting to finish.

All this talk of functional language features is great, but Lithium is still in development, Zend Framework 2.0 is a ways away, you have an upcoming project deadline and you want to know how this stuff can help you now.  Easy: go read or watch JavaScript examples.  Seriously.  Watching Douglas Crockford's videos on YUI theatre or reading through ExtJS source code can give you really good insight into the power of functional language features.  The syntax may be different, but the core ideas are the same.

The new functional feel of PHP seems to have started a trend towards a unified constructor.  This has been a common practice in the JavaScript community for some time.  The great thing is that the PHP array is very similar to the JavaScript object.  In fact, the JSON extension to PHP makes them completely interchangeable.  Here is a quick example of one unified constructor implementation in PHP:

<?php
 
$p = array(
    'a' => 'hi',
    'adder' => function($n) { return $n + 1; },
    'c' => 3,
    'd' => new stdClass
);
 
class base {
    function __construct(array $params)
    {
        foreach ($params as $key => $value) {
            $this->$key = $value;
        }
    }
}
 
class foo extends base { }
 
$foo = new foo($p);

I have a bunch of ideas (some great, some maybe not so great) that I plan on implementing using lambda functions and closures. I will be adding new components to my Crimson library and discussing them here.