4

To quote PHP:

Anonymous functions are currently implemented using the Closure class. This is an implementation detail and should not be relied upon.

Now, that said, the following checks are deemed unreliable:

function myFunction(Closure $callback){}

if(!($callback instanceof Closure)){}

Which brings us to using is_callable(). This is fine, however if one requires a true "closure", (as an argument, or what-such) then is_callable() isn't strict enough. The following of course dumps bool(true) for each:

function myFunction(){}

class MyClass{
    public function __invoke(){}
}

var_dump(is_callable('myFunction'));
var_dump(is_callable(new MyClass));

How, without relying on the Closure class (given is is in fact unreliable) can one strictly identify a "closure"?

Update

It has occurred to me I was falling in the direction of bad design. However, despite this question being answered, I think it would be appreciated if anyone could suggest answers to the posed question, if not purely for the academic element of it.

Update (again)

Since the release of PHP 5.4 (awhile ago now) the Closure type is no longer an "implementation detail", and can be relied on. function f(Closure $g) { } is all good.

Improve this question
9
  • 3
    "strictly identify a Closure". Wouldn't that be at direct odds with the concept of an anonymous function? Commented Jul 14, 2011 at 20:36
  • Why do you need an instance of Closure? Commented Jul 14, 2011 at 20:36
  • @lonesomeday - If user-code is passing __invoke-able objects or function names by string, it will convolute the module I'm working on, and it's intended purpose. Commented Jul 14, 2011 at 20:39
  • @George Cummins - No, I wouldn't think so. By "strictly identify a closure", I mean identify that it's not an __invoke-able object or string function name. Commented Jul 14, 2011 at 20:42
  • 2
    I'm with George: If you really need an object of an specific type, why you don't create it (see interface, e.g. interface Action { public function exec($arg);})? Thats much more OOPish. I cannot imagine one single purpose, why it should make sense to restrict callables to a single kind... I don't know, what you are trying to achieve, but maybe there will be situations, where a single closure gets much too complex and packing its functionality into a callable class makes the code much cleaner. Commented Jul 14, 2011 at 20:45

3 Answers 3

Reset to default
6

It seems that PHP developers changed their mind about Closure class being an implementation detail:

Anonymous functions, implemented in PHP 5.3, yield objects of this type. This fact used to be considered an implementation detail, but it can now be relied upon.

See http://php.net/manual/en/class.closure.php

Therefore you should consider now your checks are reliable:

function myFunction(Closure $callback){}

if(!($callback instanceof Closure)){}
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

I like it! :) Good find @Radu
perfect, I was having the same dilemma :)
3

The only time you should be typing arguments is when there is something about that particular class which you need. Even then, you are better off with use of an interface. That is just good OOP design.

I cannot fathom the existence of a situation where there would be a benefit to forcing something to be a Closure. The only thing which should matter, in that case, is whether or not the parameter "is_callable". Even if it were possible to accomplish your goal, I would argue that it is unexpected functionality of a framework and therefore anti-pattern.

Improve this answer

3 Comments

Thanks @cwallenpoole - When you put it that way, you're right. If the client-code is trying to do something odd, that'll come out in the woodwork anyways. And if they create a fancy hack to support otherwise unsupported functionality by passing an __invoke-able object, then I should retrofit the application to support their findings. Complete change of heart happening here. Thanks again.
@cwallenpoole, There's benefit in not using is_callable. I would say is_callable is too wide. It accepts a ton of things and this may make bugs harder to catch, for the same reason lenient code make bugs harder to catch than strict style.
@Pacerier If he's creating a framework, then using "is_callable" seems like it would be a sufficient check, though. I see not problems with "Is the thing I'm about to call callable? No? Then let them no about it. Otherwise, call it."
2

Static / Global functions would be a string, and OOP callables are an array... So couldn't you:

if ( ! is_string( $var ) && ! is_array( $var ) && is_callable( $var ) )

I too needed strict Closures. Why? My DB abstraction layer has its queries / configurations segregated from the rest of my application. I've implemented Tier / Shard features, where a key represents a DB which can then be loaded on demand (or was previously loaded.) This key could be for example 'default' and if such a function existed on the global scope (doubtful as I code mostly OOP,) I would NOT want it to be called and instead use the key.

Continuing the above code:

{
    $var = $var( $inputs );
}

$inputs are values used for query generation, allowing the Closure to return a different key based on its values. Hence, with proper design techniques, Sharding is now possible.

Of course my situation is irrelevant, but I hope it may help another.

Improve this answer

1 Comment

Similar but a little shorter: if (is_object($conditions) && is_callable($conditions))

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.