PHP 7 interfaces, return type hinting and self
UPDATE: PHP 7.4 now does support covariance and contravariance which addresses the major issue raised in this question.
I have run into something of an issue with using return type hinting in PHP 7. My understanding is that hinting : self means that you intend for an implementing class to return itself. Therefore I used : self in my interfaces to indicate that, but when I tried to actually implement the interface I got compatibility errors.
The following is a simple demonstration of the issue I've run into:
interface iFoo
{
public function bar (string $baz) : self;
}
class Foo implements iFoo
{
public function bar (string $baz) : self
{
echo $baz . PHP_EOL;
return $this;
}
}
(new Foo ()) -> bar ("Fred")
-> bar ("Wilma")
-> bar ("Barney")
-> bar ("Betty");
The expected output was:
Fred Wilma Barney Betty
What I actually get is:
PHP Fatal error: Declaration of Foo::bar(int $baz): Foo must be compatible with iFoo::bar(int $baz): iFoo in test.php on line 7
The thing is Foo is an implementation of iFoo, so as far as I can tell the implementation should be perfectly compatible with the given interface. I could presumably fix this issue by changing either the interface or the implementing class (or both) to return hint the interface by name instead of using self, but my understanding is that semantically self means "return the instance of the class you just called the method on". Therefore changing it to the interface would mean in theory that I could return any instance of something that implements the interface when my intent is for the invoked instance is what will be returned.
Is this an oversight in PHP or is this a deliberate design decision? If it's the former is there any chance of seeing it fixed in PHP 7.1? If not then what is the correct way of return hinting that your interface expects you to return the instance you just called the method on for chaining?
self return type is supposed to work?
self to mean "Return the instance you called this on, and not some other instance that implements the same interface". I seem to remember Java had a similar return type (though it's been a while since I did any Java programming)
editorial note: the answer below is outdated. as php PHP7.4.0, the following is perfectly legal:
<?php
Interface I{
public static function init(?string $url): self;
}
class C implements I{
public static function init(?string $url): self{
return new self();
}
}
$o = C::init("foo");
var_dump($o);
3v4l: https://3v4l.org/VYbGn
original answer:
self does not refer to the instance, it refers to the current class. There is no way for an interface to specify that the same instance must be returned - using self in the manner you're attempting would only enforce that the returned instance be of the same class.
That said, return type declarations in PHP must be invariant while what you're attempting is covariant.
Your use of self is equivalent to:
interface iFoo
{
public function bar (string $baz) : iFoo;
}
class Foo implements iFoo
{
public function bar (string $baz) : Foo {...}
}
which is not allowed.
The Return Type Declarations RFC has this to say:
The enforcement of the declared return type during inheritance is invariant; this means that when a sub-type overrides a parent method then the return type of the child must exactly match the parent and may not be omitted. If the parent does not declare a return type then the child is allowed to declare one. ... This RFC originally proposed covariant return types but was changed to invariant because of a few issues. It is possible to add covariant return types at some point in the future.
For the time being at least the best you can do is:
interface iFoo
{
public function bar (string $baz) : iFoo;
}
class Foo implements iFoo
{
public function bar (string $baz) : iFoo {...}
}
It also can be a solution, that you don't define explicitly the return type in the Interface, only in the PHPDoc and then you can define the certain return type in the implementations:
interface iFoo
{
public function bar (string $baz);
}
class Foo implements iFoo
{
public function bar (string $baz) : Foo {...}
}
Foo just use self.
PHP 8 will add "static return type" which will solve your problem.
Check out this RFC: https://wiki.php.net/rfc/static_return_type
This looks like the expected behavior to me.
Just change your Foo::bar method to return iFoo instead of self and be done with it.
Explanation:
self as used in the interface means "an object of type iFoo."
self as used in the implementation means "an object of type Foo."
Therefore, the return types in the interface and the implementation are clearly not the same.
One of the comments mentions Java and whether you would have this issue. The answer is yes, you would have the same issue if Java allowed you to write code like that -- which it doesn't. Since Java requires you to use the name of the type instead of PHP's self shortcut, you are never going to actually see this. (See here for a discussion of a similar issue in Java.)
self, similar to declaring MyClass::class?
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now相似问题
- What should main() return in C and C++?
- Detecting request type in PHP (GET, POST, PUT or DELETE)
- Secure hash and salt for PHP passwords
- startsWith() and endsWith() functions in PHP
- Why PHP Trait can't implement interfaces?
- How should I have explained the difference between an Interface and an Abstract class?
- How to specify multiple return types using type-hints
- How do I add default parameters to functions when using type hinting?
staticto work, but it isn't even recognisedstaticis being added to PHP 8./** @return Foo */(if you cannot upgrade your PHP version). At least, that way the IDE would be suggesting the right typehint. Tested it with Netbeans.