A way to encapsulate a callable
This package is made to encapsulate a callable of any type, providing the ability to handle them the same way. I needed this kind of package for routing or a service manager, any task to defer, to encapsulate callables correctly...
v0.4.0
- CallableType abstract getReflection() method.
Use the CallWrapper factory static methods to build a CallableType :
class Foo
{
public function bar(){}
public function __invoke(){}
public static function biz(){}
}
// To wrap a Closure
$closureWrapper = CallWrapper::wrap(fn(string $name) => 'hello ' . $name);
// or
$closureWrapper = CallWrapper::wrapClosure(fn(string $name) => 'hello ' . $name);
// to wrap an instance and a method to call
$methodWrapper = CallWrapper::wrap([new Foo(), 'bar']);
// or
$methodWrapper = CallWrapper::wrapMethod(new Foo(), 'bar');
// to wrap a static method
$staticWrapper = CallWrapper::wrap([Foo::class, 'biz']);
// or
$staticWrapper = CallWrapper::wrapStatic(Foo::class, 'biz');
// To wrap an invokable class
$invokable = CallWrapper::wrap(new Foo());
// or
$invokable = CallWrapper::wrapInvokable(new Foo());
The use of this factory is the best choice to build and use a CallableType. Some checks make direct instanciation unavailable due to private constructors.
A CallableType is able to run the callable it holds. For external needs, it is able to give its callable back as is :
$callable = $closureWrapper->callable();
echo call_user_func($callable,' John'); // prints "hello John"
// or use it directly
echo $closureWrapper->apply(['name' => 'John']); // same result
- CallableType::apply(?iterable): mixed : execute callable and return the result
- CallableType::action(): callable : return wrapped callable type-hinted as callable
- CallableType::getCallable(): object : return wrapped callable fully type-hinted
I could enumerate 4 use cases for a callable wrap :
- a Closure
- a class method, with an instance and the method to run
- a static class method, with a class-string instead of an instance
- an instance with __invoke magic method
If you can find more, feel free to use CallableType abstraction.
Holds a Closure. Direct instanciation (public constructor)
No Errors/Exceptions thrown
Holds an invokable instance. Static factory method for checks.
Throws an UninvokableClassException if the given instance does not implement __invoke() method.
Holds an instance and a method. Static factory method for checks.
Throws a MethodNotImplementedException if given method is not implemented.
getCallable method returns a ClassMethod instance with a get() method returning the callable array.
Holds a class name and a method name. Static factory for checks.
Throws a ClassNotFoundException if given class does not exist. Throws a MethodNotImplementedException if given method is not implemented.
getCallable method returns a ClassMethod instance with a get() method returning the callable array.