php[architect] November 2018

http://www.phparch.com \ November 2018 \ 5

The Case for Generics in PHP

I could also make a DuckArrayCollection (Listing 5).
Every time I wish to have an ArrayCollection of homog-
enous items, I have to make a new ArrayCollection class to
enforce this contract. This would allow me to write the code
in Listing 6.

Generics to the Rescue

My ultimate wish would be to signal that the method would
return “an ArrayCollection of User objects” without creating
a new child class for every type of object I might return. It’s
an ArrayCollection whose members are only allowed to be
instances of the User class. Here’s a possible evolution of the
previous example.

public class UserLookupService
{
public function getUsersByDepartmentName(
string $departmentName ) : ArrayCollection[User]
{
return $this->userRepo
->getByDepartment($departmentName);
}
}

What I wish I could do is this:

class UserLookupService
{
// ...
public function getUsersByDepartmentName(
string $departmentName) : User[] //<-- Not valid
{
return $this->userRepo
->getByDepartment($departmentName);
}
}

The brackets syntax is common in many languages to desig-
nate arrays, but this isn’t what we’re working with here. In the
end, what we are trying to define is a composite type. It’s an
object of a given type—ArrayCollection—made of objects of
another type—User.

The Generics RFC’s proposed syntax for this would be:

ArrayCollection

Applying Generics

The collections examples look tedious. Generics would
allow us to remove this tedium, as in Listing 7.

The letter T acts as a placeholder for whichever type I need
to bind my GenericArrayCollection, and this binding happens
at instantiation.

$duckCollection = new GenericArrayCollection();

From here on, the add method will only accept a Duck. And
the next method is guaranteed to only ever return an instance
of Duck.

Based on the above examples, from this single

GenericArrayCollection class, I can now write Listing 8.

With this generics syntax, our UserLookupService class

could now look like Listing 9.

With the above example, we are now guaranteeing the

method would always return a collection of User objects.

Listing 5

1. <?php


2. 
   


3. class DuckArrayCollection extends ArrayCollection


4. {


5. public function addDuck(Duck $duck) {


6. parent::add($duck);


7. }


8. 
   


9. public function nextDuck(): Duck {


10. return parent::next();


11. }


12. }

Listing 6

1. // type-specific collection class for "User"


2. $users = new UserArrayCollection();


3. 
   


4. // this is fine


5. $users->addUser(new User());


6. 
   


7. // this breaks, as intended


8. $users->addUser(new Duck());


9. 
   


10. // type-specific collection class for "Duck"


11. $ducks = new DuckArrayCollection();


12. 
    


13. // this is fine


14. $ducks->addDuck(new Duck());


15. 
    


16. // this breaks, as intended


17. $ducks->addDuck(new User());

Listing 7

1. <?php


2. 
   


3. 
   

   //don't extend ArrayCollection, re-implement from scratch

   
   


4. class GenericArrayCollection


5. {


6. public function add(T $element) {


7. $this->elements[] = $element;


8. return true;


9. }


10. 
    


11. public function next(): T {


12. return next($this->elements);


13. }


14. }