PHP: Covariance et Contravariance

Covariance et Contravariance

À partir de PHP 7.2.0, la contravariance partielle a été introduite en supprimant les restrictions de type sur les paramètres d'une méthode enfant. À partir de PHP 7.4.0, la covariance et la contravariance complètes ont été ajoutées.

La covariance permet à une méthode enfant de retourner un type plus spécifique que le type de retour de sa méthode parente. La contravariance permet à un type de paramètre d'être moins spécifique dans une méthode enfant que dans celui de la méthode parente.

Une déclaration de type est considérée comme plus spécifique dans le cas suivant :

Un type est retiré d'un type union
Un type est ajouté à un type d'intersection
Un type de classe est transformé en un type de classe enfant
iterable est remplacé par array ou Traversable

Un type de classe est considéré moins spécifique si l'inverse est vrai.

Covariance

Pour illustrer le fonctionnement de la covariance, une simple classe parente abstraite, Animal est créée. Animal sera étendu par des classes enfants, Cat et Dog.

<?php

abstract class Animal
{
    protected string $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }

    abstract public function speak();
}

class Dog extends Animal
{
    public function speak()
    {
        echo $this->name . " barks";
    }
}

class Cat extends Animal
{
    public function speak()
    {
        echo $this->name . " meows";
    }
}

Notez qu'il n'y a pas de méthodes qui renvoient des valeurs dans cet exemple. Quelques fabriques seront ajoutées et renverront un nouvel objet de classe de type Animal, Cat, ou Dog.

<?php

interface AnimalShelter
{
    public function adopt(string $name): Animal;
}

class CatShelter implements AnimalShelter
{
    public function adopt(string $name): Cat // au lieu de renvoyer le type de classe Animal, il peut renvoyer le type de classe Cat
    {
        return new Cat($name);
    }
}

class DogShelter implements AnimalShelter
{
    public function adopt(string $name): Dog // au lieu de renvoyer le type de classe Animal, il peut renvoyer le type de classe Dog
    {
        return new Dog($name);
    }
}

$kitty = (new CatShelter)->adopt("Ricky");
$kitty->speak();
echo "\n";

$doggy = (new DogShelter)->adopt("Mavrick");
$doggy->speak();

L'exemple ci-dessus va afficher :

Ricky meows
Mavrick barks

Contravariance

En reprenant l'exemple précédent avec les classes Animal, Cat et Dog, deux classes appelées Food et AnimalFood sont incluses, et une méthode eat(AnimalFood $food) est ajoutée à la classe abstraite Animal .

<?php

class Food {}

class AnimalFood extends Food {}

abstract class Animal
{
    protected string $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }

    public function eat(AnimalFood $food)
    {
        echo $this->name . " eats " . get_class($food);
    }
}

Afin de voir le comportement de la contravariance, la méthode méthode eat est surchargée dans la classe Dog afin d'autoriser n'importe quel objet de type Food. La classe Cat reste inchangée.

<?php

class Dog extends Animal
{
    public function eat(Food $food) {
        echo $this->name . " eats " . get_class($food);
    }
}

L'exemple suivant montre le comportement de la contravariance.

<?php

$kitty = (new CatShelter)->adopt("Ricky");
$catFood = new AnimalFood();
$kitty->eat($catFood);
echo "\n";

$doggy = (new DogShelter)->adopt("Mavrick");
$banana = new Food();
$doggy->eat($banana);

L'exemple ci-dessus va afficher :

Ricky eats AnimalFood
Mavrick eats Food

Mais que se passe-t-il si $kitty essaie de manger (eat()) la banane ($banana) ?

$kitty->eat($banana);

L'exemple ci-dessus va afficher :

Fatal error: Uncaught TypeError: Argument 1 passed to Animal::eat() must be an instance of AnimalFood, instance of Food given

Variation de type des propriétés

Par défaut, les propriétés ne sont ni covariantes ni contravariantes, donc invariantes. Autrement dit, leur type ne peut pas du tout changer dans une classe enfant. La raison en est que les opérations "get" doivent être covariantes, et les opérations "set" doivent être contravariantes. La seule façon pour une propriété de satisfaire ces deux exigences est d'être invariante.

À partir de PHP 8.4.0, avec l'ajout des propriétés abstraites (sur une interface ou une classe abstraite) et propriétés virtuelles, il est possible de déclarer une propriété qui n'a qu'une opération "get" ou "set". En conséquence, les propriétés abstraites ou les propriétés virtuelles qui n'ont que l'opération "get" requise peuvent être covariantes. De même, une propriété abstraite ou une propriété virtuelle qui n'a que l'opération "set" requise peut être contravariante.

Cependant, une fois qu'une propriété a à la fois une opération "get" et "set", elle n'est plus covariante ni contravariante pour une extension future. Autrement dit, elle devient désormais invariante.

Exemple #1 Variation du type des propriétés

<?php
class Animal {}
class Dog extends Animal {}
class Poodle extends Dog {}

interface PetOwner
{
    // Seule l'opération "get" est requise, donc cela peut être covariant.
    public Animal $pet { get; }
}

class DogOwner implements PetOwner
{
    // Cela peut être un type plus restrictif, car le côté "get"
    // retourne toujours un Animal. Cependant, en tant que propriété native,
    // les enfants de cette classe ne peuvent plus changer le type.
    public Dog $pet;
}

class PoodleOwner extends DogOwner
{
    // Ceci N'EST PAS AUTORISÉ, car DogOwner::$pet a à la fois
    // les opérations "get" et "set" définies et requises.
    public Poodle $pet;
}
?>

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

＋add a note

User Contributed Notes 3 notes

down

xedin dot unknown at gmail dot com ¶

4 years ago

I would like to explain why covariance and contravariance are important, and why they apply to return types and parameter types respectively, and not the other way around.

Covariance is probably easiest to understand, and is directly related to the Liskov Substitution Principle. Using the above example, let's say that we receive an `AnimalShelter` object, and then we want to use it by invoking its `adopt()` method. We know that it returns an `Animal` object, and no matter what exactly that object is, i.e. whether it is a `Cat` or a `Dog`, we can treat them the same. Therefore, it is OK to specialize the return type: we know at least the common interface of any thing that can be returned, and we can treat all of those values in the same way.

Contravariance is slightly more complicated. It is related very much to the practicality of increasing the flexibility of a method. Using the above example again, perhaps the "base" method `eat()` accepts a specific type of food; however, a _particular_ animal may want to support a _wider range_ of food types. Maybe it, like in the above example, adds functionality to the original method that allows it to consume _any_ kind of food, not just that meant for animals. The "base" method in `Animal` already implements the functionality allowing it to consume food specialized for animals. The overriding method in the `Dog` class can check if the parameter is of type `AnimalFood`, and simply invoke `parent::eat($food)`. If the parameter is _not_ of the specialized type, it can perform additional or even completely different processing of that parameter - without breaking the original signature, because it _still_ handles the specialized type, but also more. That's why it is also related closely to the Liskov Substitution: consumers may still pass a specialized food type to the `Animal` without knowing exactly whether it is a `Cat` or `Dog`.

down

Hayley Watson ¶

2 years ago

The gist of how the Liskov Substition Princple applies to class types is, basically: "If an object is an instance of something, it should be possible to use it wherever an instance of something is allowed". The Co- and Contravariance rules come from this expectation when you remember that "something" could be a parent class of the object.

For the Cat/Animal example of the text, Cats are Animals, so it should be possible for Cats to go anywhere Animals can go. The variance rules formalise this.

Covariance: A subclass can override a method in the parent class with one that has a narrower return type. (Return values can be more specific in more specific subclasses; they "vary in the same direction", hence "covariant").
If an object has a method you expect to produce Animals, you should be able to replace it with an object where that method produces only Cats. You'll only get Cats from it but Cats are Animals, which are what you expected from the object.

Contravariance: A subclass can override a method in the parent class with one that has a parameter with a wider type. (Parameters can be less specific in more specific subclasses; they "vary in the opposite direction", hence "contravariant").
If an object has a method you expect to take Cats, you should be able to replace it with an object where that method takes any sort of Animal. You'll only be giving it Cats but Cats are Animals, which are what the object expected from you.

So, if your code is working with an object of a certain class, and it's given an instance of a subclass to work with, it shouldn't cause any trouble:
It might accept any sort of Animal where you're only giving it Cats, or it might only return Cats when you're happy to receive any sort of Animal, but LSP says "so what? Cats are Animals so you should both be satisfied."

down

Anonymous ¶

4 years ago

Covariance also works with general type-hinting, note also the interface:

interface xInterface
{
    public function y() : object;
}

abstract class x implements xInterface
{
    abstract public function y() : object;
}

class a extends x
{
    public function y() : \DateTime
    {
        return new \DateTime("now");
    }
}

$a = new a;
echo '<pre>';
var_dump($a->y());
echo '</pre>';

＋add a note