In a new post to his blog today Eli White takes a look at an interesting use of lambda functions he's figured out for a his development at work.

I found a very specific use out of the blue of Lambda functions that I have now used and I see as a great use-case. Which is specifically passing functions/logic from your Controller to your View. In the case of Goodsie, I'm using PHP for my templating language and as usual I'm trying to remove as much logic from my View as possible, while still allowing the view to be malleable.

His method centered around a pagination subview that he wanted to make flexible enough to work with both the standard page view and with an ajax request. Lambda functions came to the rescue by dynamically creating a function based on the request need.

Those still trying to get a handle on anonymous functions, lambdas and closures in the recently released 5.3 version of PHP might want to take a look at this new tutorial from the Recess blog. It's the first part of their "Functional PHP 5.3" series.

One of the most exciting features of PHP 5.3 is the first-class support for anonymous functions. You may have heard them referred to as closures or lambdas as well. There's a lot of meaning behind these terms so let's straighten it all out.

They explain the differences between closures and lambda functions (hint: not much) and give code examples for both them and closures.

On the PHP in Action blog Dagfinn Reiersol continues his look at real programming examples using the upcoming PHP 5.3 release. In this new tutorial he focuses on making a classed based on the Range design pattern to paginate results.

A Range object is defined by just two values (three in my variation), so it might seem like too much to have an object just to keep these values, but as you can see from the example, a Range class can have behaviors to change and compare ranges.

He gives two code snippets - the first defines most of the methods of the class in the constructor (using the lambda functions) and the second uses a __call to catch the calls to the same methods but defined normally as private (making them inaccessible to the outside world).

This new post to the PHPClasses.org blog take a look at some of the new features that will be included in the PHP 5.3 release (coming soon to a web server near you!) by way of an interview with Lukas Smith.

his article presents an interview with core PHP developer Lukas Kahwe Smith that has pushed many of the new features of PHP 5.3 as release manager. Lukas talks about PHP 5.3 new features such as lambda functions, closures and PHAR support. He also explains what are traits, which for now it is a feature that was left out of PHP 5.3. He also talks about future PHP 5.x and PHP 6, as well how anybody can help in the development of PHP to make it come out faster.

They talk about the PHP.net wiki, briefly touch on the PHP 5.3 feature updates, performance/memory usage in the new version, Lambda functions, closures and PHAR and what's to come with PHP 6.

In this new post to his blog Fabien Potencier looks at two of the much-hyped features of the upcoming PHP 5.x series release (5.3) - closures and lambda functions.

I won't talk too much about what lambda functions or closures are, as you can find many good blog posts describing them in great details. To sum up, a lambda function is an anonymous PHP function that can be stored in a variable and passed as an argument to other functions or methods. A closure is a lambda function that is aware of its surrounding context.

He includes several examples including how they would work with a few of the array functions, an implementation of the Y-combinator method (as written by Stanislav Malyshev) and how they can be used to create dependency injection functionality.

On his blog today Dagfinn Reiersol has posted the next part of his "real programming with PHP 5.3" series looking at links.

After the previous post in this series, additional independent implementations of the idea of JavaScript-style classes have turned up. So I'm going to list them and comment briefly on the differences. I hope this will be helpful to anyone who actually wants to use this in practice and needs to decide on the details of the implementation.

The previous article looked at Javascript-style classes that can be build with the new closures/lambda function support that PHP 5.3 will include. A few of the other examples of this method he mentions include this look from Ionut Stan's forum post and Andrea Giammarchi's blog post on making a Javascript object-like class.

On t Dagfinn Reiersol'sblog, there's a new post that's the second part of a series on "real programming" with the upcoming PHP 5.3 release.

In part one of this series, we looked at the ability to use lambda functions or closures to process arrays. In this part, we will see how closures can be used to build classes in a completely new way. After I did my own research, I discovered that someone had beat me to it.

He compares the two approaches - one defining closures in the constructor, the other as they're needed - and some code showing the creation and use of the lambda functions (using __call and call_user_func_array to catch those requests).

In this recent post to his blog Juozas Kaziukenas looks at one of the features in the next major upcoming release of PHP (5.3) - lambda functions (anonymous functions).

Only some days ago PHP.net introduced lambda functions (+ closures) are most anticipated, because they'll increase flexibility and good-looks of code a lot. Today I'm going to try to prove why lambda functions are so useful.

He looks at what lambda functions are and one of their more apparent uses - sorting. He gives an example working with information about authors and their books, sorting them by publisher and title.

Jeff Moore has a new post showing an example of a feature that will be included in the upcoming PHP 5.3 release - closures/lambda functions.

Dagfinn has a post looking at using the new closure feature of PHP 5.3. He compares using foreach for iteration versus array_map. "Interesting," he concludes, "but not necessarily better than conventional alternatives." I agree for that case. Consider instead, a more complicated operation that requires a setup and a tear down after.

Jeff's example proposes that, instead of duplicating code, you use a lambda function to handle the custom parsing of the data as needed and pass that into the "doIt" function in his example.

On the PHP in Action blog, a new series has been kicked off with this first part looking at "real programming" in the upcoming PHP 5.3 release.

You may have heard of the new features that are scheduled for PHP 5.3, but who knows what they can be used for in real programming? I took the time for some experimental research, and came up with a few examples.

This first part focuses on the new lambda/closures functionality that will come with the new release. He compares it to the create_function syntax currently offered, specifically when it comes to sorting and manipulating arrays.