Interfacce PHP 7, suggerimenti sul tipo di ritorno e self

AGGIORNAMENTO : PHP 7.4 ora supporta covarianza e controvarianza che risolvono il problema principale sollevato in questa domanda.

Ho riscontrato un problema con l'utilizzo dell'hinting del tipo di ritorno in PHP 7. La mia comprensione è che hinting : selfsignifica che si intende che una classe di implementazione ritorni da sola. Pertanto ho usato : selfnelle mie interfacce per indicarlo, ma quando ho provato a implementare effettivamente l'interfaccia ho ricevuto errori di compatibilità.

Quanto segue è una semplice dimostrazione del problema che ho riscontrato:

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");

L'output previsto era:

Fred Wilma Barney Betty

Quello che ottengo effettivamente è:

Errore irreversibile PHP: Dichiarazione di Foo :: bar (int $ baz): Foo deve essere compatibile con iFoo :: bar (int $ baz): iFoo in test.php alla riga 7

Il fatto è che Foo è un'implementazione di iFoo, quindi per quanto ne so l'implementazione dovrebbe essere perfettamente compatibile con l'interfaccia data. Presumibilmente potrei risolvere questo problema modificando l'interfaccia o la classe di implementazione (o entrambi) per restituire un suggerimento sull'interfaccia per nome invece di utilizzarlo self, ma la mia comprensione è che semanticamente selfsignifica "restituire l'istanza della classe su cui hai appena chiamato ". Pertanto, cambiarlo nell'interfaccia significherebbe in teoria che potrei restituire qualsiasi istanza di qualcosa che implementa l'interfaccia quando il mio intento è che l'istanza invocata sia ciò che verrà restituito.

È una svista in PHP o è una decisione di progettazione deliberata? Se è il primo, c'è qualche possibilità di vederlo corretto in PHP 7.1? In caso contrario, qual è il modo corretto di restituire suggerendo che la tua interfaccia si aspetta che tu restituisca l'istanza su cui hai appena chiamato il metodo per il concatenamento?

selfnon si riferisce all'istanza, si riferisce alla classe corrente. Non è possibile che un'interfaccia specifichi che deve essere restituita la stessa istanza : utilizzare selfnel modo in cui si sta tentando si imporrebbe solo che l'istanza restituita sia della stessa classe.

Detto questo, le dichiarazioni del tipo di ritorno in PHP devono essere invarianti mentre ciò che stai tentando è covariante.

Il tuo utilizzo selfè equivalente a:

interface iFoo
{
    public function bar (string $baz) : iFoo;
}

class Foo implements iFoo
{

    public function bar (string $baz) : Foo  {...}
}

che non è consentito.

Le dichiarazioni del tipo di ritorno RFC hanno questo da dire :

L'applicazione del tipo restituito dichiarato durante l'ereditarietà è invariante; questo significa che quando un sottotipo sovrascrive un metodo genitore, il tipo restituito del figlio deve corrispondere esattamente al genitore e non può essere omesso. Se il genitore non dichiara un tipo restituito, il figlio può dichiararne uno.

...

Questa RFC originariamente proponeva tipi restituiti covarianti, ma è stata modificata in invariante a causa di alcuni problemi. È possibile aggiungere tipi restituiti covarianti in futuro.

Per il momento almeno il meglio che puoi fare è:

interface iFoo
{
    public function bar (string $baz) : iFoo;
}

class Foo implements iFoo
{

    public function bar (string $baz) : iFoo  {...}
}

Può anche essere una soluzione, che non si definisce esplicitamente il tipo di ritorno nell'interfaccia, solo nel PHPDoc e quindi è possibile definire il determinato tipo di ritorno nelle implementazioni:

interface iFoo
{
    public function bar (string $baz);
}

class Foo implements iFoo
{
    public function bar (string $baz) : Foo  {...}
}

Nel caso in cui, quando vuoi forzare dall'interfaccia, quel metodo restituirà oggetto, ma il tipo di oggetto non sarà il tipo di interfaccia, ma la classe stessa, allora puoi scriverlo in questo modo:

interface iFoo {
    public function bar (string $baz) : object;
}

class Foo implements iFoo {
    public function bar (string $baz) : self  {...}
}

Funziona da PHP 7.4.

PHP 8 aggiungerà "tipo di ritorno statico" che risolverà il tuo problema.

Dai un'occhiata a questo RFC: https://wiki.php.net/rfc/static_return_type

Questo mi sembra il comportamento previsto.

Cambia semplicemente il tuo Foo::barmetodo per tornare iFooinvece di selfe basta.

Spiegazione:

selfcome usato nell'interfaccia significa "un oggetto di tipo iFoo".
selfcome usato nell'implementazione significa "un oggetto di tipo Foo".

Pertanto, i tipi restituiti nell'interfaccia e nell'implementazione chiaramente non sono gli stessi.

Uno dei commenti menziona Java e se avresti questo problema. La risposta è sì, avresti lo stesso problema se Java ti permettesse di scrivere codice come quello, cosa che non fa. Dato che Java richiede di usare il nome del tipo invece del selfcollegamento di PHP , non lo vedrai mai. (Vedi qui per una discussione su un problema simile in Java.)