On 1/20/2017 8:04 AM, Rasmus Schultz wrote:
> Just a quick thought.
>
> Since the autoloading functions proposal is stalled, how about allowing for
> import of static functions instead?
>
> use function Foo::bar;
>
> bar(); // calls Foo::bar()
>
> There are two benefits to this approach:
>
> 1. There is immediate support for autoloading without any need for adoption
> or support in existing autoloaders.
>
> 2. Pseudo-namespaces (abstract classes with stateless static functions) are
> already widely practiced in PHP - a lot of existing code would be supported
> as is.
>
> The syntax when calling functions would be the same.
>
> If we had function autoloading, we would likely collect related functions
> in a file anyway - putting them in a class instead gives more less the same
> exact result.
>
> The only drawback I can see, is the inability to import a whole set of
> functions with one statement - but being explicit about external imports is
> widely considered best practice for classes and interfaces, so why not for
> functions. Yeah, it's a bit inconvenient, but at least we can move ahead
> and leverage existing code without changes or BC breaks. It's not all bad.
> It's better than nothing perhaps? :-)
>
> Thoughts?
>
I actually like this idea a lot, something similar is possible in Rust
with Enums.
```rust
pub use self::Foo::{A, B};
pub enum Foo {
A,
B
}
fn main() {
let a = A;
}
```
Loading a set of static methods could look similar.
```php
final class Foo {
public static function A(): self {
return new self;
}
public static function B(): self {
return new self;
}
}
```
```php
use function Foo::{A, B};
$a = A();
```
--
Richard "Fleshgrinder" Fussenegger
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
