Because of “Functional Programming” course I had in university, I love lambda functions. At first they seemed a little bit strange, but hey – in Haskell you write:

Input: map (\x => x*3) [1,2,3,4]
Output: [3,6,9,12]

No need to create for loops (which doesn’t exists in Haskell at all) and code is much more flexible. Functional languages allows creating functions which accepts functions as arguments, not only integers or floats. That’s why most functions are very short, but are very easily connectable together.

I think one the best examples of lambda functions usefulness is sorting. Image this scenario: $books collection holds books information and you need to sort it by title; author; publish year and author; publish city and title. How you are going to do it? It’s easy and you probably would write something like this:

// Sort by title
$books->sortByTitle('ASC');
// Sort by publisher year, author
$books->sortByPublishYear('DESC')->sortByAuthor('ASC');

However, it looks good and does work just fine, but it’s not very practical – you need to create functions for all keywords (title, author, publish year, etc.). You may argue, that __call() can be used and that’s absolutely true, but it’s even harder to maintain and code it, still usable though.

Nevertheless, 5.3 version of PHP introduces lambda functions (also called anonymous functions), which can simplify your work a lot (I haven’t tried running this code):

// Sort by book title
$books->sort(
    function ($book1, $book2)
    {
        return strcmp($book1->title, $book2->title);
    });
 
// Sort by publisher year, author
$books->sort(
    function ($book1, $book2)
    {
        if ($book1->publish_year == $book2->publish_year)
            return strcmp($book1->author, $book2->author);
 
        return strcmp($book2->publish_year, $book1->publish_year);
    });

It’s a little bit harder to read and maybe understand, but basically you can pass whatever comparison function you’d like. Sort function can use simple for-loop-inside-for-loop or usort and compare all elements with your function

Lambda functions are not replacement for __cal() and should be used cleverly, search and filtering with lambda functions is only one example of how useful they are. In short, lambda functions allows you to create small dynamic functions which can be used to expand and modify normal functions behaviour.

Parallel map functions does all work for you – you don’t even need to know when it’s right time to fork another thread. Implementing parallel computation in Haskell was very easy and it almost gave theoretical decrease in processing time by N times (where N is processor cores count). Today I will talk a little bit about possible parallelism with PHP’s internal POSIX functions.

PHP is neither a functional language, nor is made with threading support (correct me if I’m wrong). Still, it’s possible to create parallel processes by using pcntl_* functions family. Some days ago I tried just to get something working, what uses parallel processes and can possible be extended to deal with time-consuming mathematical algorithms.

Download my sample code here (rename extension to php) and run it in terminal (it probably wont run with Apache). This code will try to compute x^3 for 0-1M integers two times, parallel runs both in one call, normal behaviour runs one after another. Output should look similar to this:

juokaz@thinkpad:~/Desktop/php/parallel$ php run.php
We start
I am the child, pid = 0
I am the parent, pid = 2004
yep, finished, I have 2004 ID
yep, finished, I have 0 ID
Ran parallel 5.81009602547 seconds
yep, finished, I have 1 ID
yep, finished, I have 2 ID
Ran normal 9.76671719551 seconds

As you can see, parallel computation on dual core processor ran almost 2x faster. And yes, it does use both cores simultaneously.

If you want to look more deeply, there is great article called Thorough look at PHP’s pcntl_fork(). You will quite quickly find that there are problems when using pcntl_fork, because it basically clones running process and then continues. Everything you define before forking child process will be accessible inside child – it’s not always what you really want.

Parallel processes can be easily simulated by using asynchronous calls (over HTTP, for example) from one script to others, but for something more calculations-based, using pcntl_fork() can be much more practical. But I will probably still chose asyncronous calls over parallelizing because they are much more flexible.