Underscore.php

    __::map([1, 2, 3]), function($n) { return $n * 2; });
    __([1, 2, 3])->map(function($n) { return $n * 2; });

With namespaces:

    namespace _;  
    function each() {
    }

    // chaining can be achieved with this:

    class Wrapper {
        private $coll;
        function __construct($coll) {
            $this->coll = $coll;
        }
        function __call($name, $args) {
            array_unshift($this->coll,$args);
            return new self(call_user_func_array('_\\'.$name, $args));
        }
    }

    function __($coll) {
        return new Wrapper($coll);
    }

    use _;  
    _\each(...);

    // or
  
    __($coll)->each(...);

    // I can add new functions

    namespace _;
    function something(){}

    class __ {  
        function each() {  
        }  
    }

    // throws strict errors

    __::each(...);

    // can't add functions

https://github.com/lstrojny/functional-php also brings some functional stuff to php.

You do know that PHP has built-in min and max functions, right?

  And array_map. 
  And array_walk. 
  And array_filter. 
  And array_reduce. 
  And array_slice. 
  And array_unique. 
  And array_search. 
  And range. 
  And empty. 
  And is_object. 
  And is_array.

Unfortunately, there's not much in the way of documentation as of now, but a look at the API should prove illuminating. For starters, the API is meant to be inherently both chainable and extensible with room for implementations based on eg. SPL classes. The idea is for the collections not to be throwaways for intermediate processing but to instead grow into a part of your application's internal API. Although the code should be in perfect working order (we're using it in one production system currently), the concept is a bit experimental at this stage. I'd very much appreciate any comments you have.

> Underscore is a utility-belt library for JavaScript that provides a lot of the functional programming support that you would expect in Prototype.js (or Ruby), but without extending any of the built-in JavaScript objects. It's the tie to go along with jQuery's tux.

Underscore is both a utility belt and a bowtie?

Whenever I've done PHP, I've always used a hand-rolled functional library. I will certainly be using this now, though.