
Functional PHP 5.3 - What are Anonymous Functions and Closures? - KrisJordan
http://www.recessframework.org/page/functional-php-anonymous-functions-lambdas-closures
======
yannis
Good tutorial. A more practical application would have enhanced the article.
Closures in PHP, just forget them!

As a byline, it is posted at recessframework. I did not know about the
framework. Downloaded it gave it a spin and was impressed!

~~~
ErrantX
> As a byline, it is posted at recessframework. I did not know about the
> framework.

Ah thanks for that! I remember the guy posted a link here when Recess was in
it's infancy. I gave it a spin but preferred more mature offerings :)

Time to give it another go I think.

------
phicou
This should be a big help in writing clean server-side sorts by an arbitrary
column in tabular data.

Previously we've had to do some rather ugly things with "create_function" and
lots of escaping in order to make arbitrary sort comparator functions.

An example of the old style:

    
    
        private function makeCompare($field, $desc) {
            return create_function('$a,$b', "
                \$r = strcasecmp(\$a['$field'], \$b['$field']);
                return " . ($desc ? '-1' : '1') . " * \$r;");
        }
    

Not my proudest moment, to be sure.

------
HeyLaughingBoy
Nice article, but it still doesn't answer the question I've always had about
anonymous functions: why are they more "important" (read: why is everyone
making such a big deal about them) than pointers-to-functions in C? I've
written C/C++ code that pass functions as arguments to other functions by
using pointers. I could just as easily write code that returns a pointer to a
function. The only difference I see here is that anonymous functions are,
well, anonymous.

So someone clarify for me why this is any better. What am I missing?

~~~
ezy
This isn't necessarily any better, it just has more syntax support. However,
it isn't equivalent to a function ptr, it's more equivalent to a structure
with a fptr and associated data. A C++ function object or a C fptr pointing to
a trampoline fn has exactly this functionality.

However, the functionality isn't the only thing. There are two notational
conveniences that typically come along for the ride:

1) You can declare the function nested within another function. This is a
necessary prerequisite to...

2) The associated structure is automatically created by the compiler based on
what data the function uses in the surrounding context.

3) Just like the struct/fptr pair you might have created manually on the heap,
you can _return_ this function from another function _with the data it
captured coming along for the ride_. That's generally were all the fun stuff
happens :-)

To clarify this: See the recent "lambda" proposal for C++0x to see that same
feature in the context of a Cish language, with the attendant modifications
for manual memory management, stack based capture, etc.

------
gdp
Anonymous first-class functions in PHP? I can't say that was high on my list
of things I would classify as necessary to make it usable.

~~~
jcapote
Before you had to write:

    
    
      function is_not_numeric($num){
        !is_numeric($num);
      }
    
      array_map('is_not_numeric', array(1,3,5,'a','c',3));
    

The fact that php used to take a string as the callback and not an expression
is seriously broken.

Now (presumably), one can write:

    
    
      array_map(function($x){ !is_numeric($x) }, array(1,3,5,'a','c',3));
    

Although, ideally it would be:

    
    
      array_map(!is_numeric, array(1,3,5,'a','c',3));

~~~
gdp
Right, I'm not arguing that anonymous first-class functions are _useful_ , I'm
just saying that I think there are so many other things that are seriously
broken with PHP as to make this akin to worrying about having enough clean
forks for a dinner party while your house is on fire.

I'm not just PHP-trolling here, either. There is a history in the PHP project
of adding features to the language without any reference to how they will be
made "safe". The PHP interpreter is notoriously unhelpful at catching even the
simplest of bugs. This just seems like another ad-hoc feature added to the
list of things that are likely to introduce subtle bugs that are undetectable
until they are running on a production system somewhere.

~~~
mgreenbe
Seriously. Anonymous functions without a sane lexical system is asking for
trouble, though marking closure variables will mitigate the problems a little.

I agree that PHP's house is on fire, but PHP has such a big house that I'm not
sure it's noticed yet.

------
pbhjpbhj
"intents and purposes"

~~~
KrisJordan
Fixed. Thanks.

