There are tactical reasons to adopt strong typehint: easy validation, less code, fashionable. Besides, the first typehints blend in effortlessly with the current application: it is as if typehint was already there. Later, it appears that scalar types paved the way to more substantial code refactoring. Classes emerge from the initial scalar types, code congregate around important values, types gets more complex. Finally, systemic typehint arrives. Type hints become systemic when they help tame the class dependency hell, and help us plan for the new code. During the session, we’ll cover the various stages of using typehints, with their advantages, and when not to overuse them.

1. PHP Leeds, Wales, United Kingdom
Strong typing in PHP
adoption, evolution and organisation

2. AGENDA
• PHP Type hints system
• Adoption
• Evolution
• Organisation

3. SPEAKER
• Damien Seguy
• CTO @exakat
• Static analysis expert
• Retirement home for elePHPants

4. Everyone uses typehinting
97%
3%
With Typehints Without typehint

5. No
typeh
ints
Adoption Hard
part
A
d
or
at
or
s
Everyone uses typehinting

6. Adoption

7. Typehints as debug tactics
• Set up a typehint
• Wait for the 'Fatal error'
• Fix the calling code, now that you know where it is
• Remove it in production
• Leave it in development
<?php
foo("a");
foo(1);
foo(new x);
foo(array());
function foo(string $s) {
echo $s;
}
class x {
function __toString()
{ return "a"; }
}
?>

8. Your code is already typed
• Typehints are already used in the code
• PHP, and strict_types
• is_string(), is_array(), instanceof…
• Coding conventions

9. Coding conventions
• The type is in the name of the argument
• $string, $array
• $user = new User();
<?php
function shorten($string) {
return substr($string, 0, 5);
}
function getPattern(array $ints) { }
function (StringClass $string) { }
?>

10. Moving type checks to the signature
• is_a(), is_subclass_of(), instanceof, ===
null
• is_string(), is_array()
• (int), (string)…
<?php
function bar($user) {
if ($user === null) {
throw new TypeError();
}
if (!$user instanceof User)) {
throw new TypeError();
}
return $user->validate();
}
?>

11. Moving type checks to the signature
• is_a(), is_subclass_of(), instanceof, ===
null
• is_string(), is_array()
• (int), (string)…
<?php
function bar(Usager $user) {
return $user->validate();
}
?>

12. Moving type checks to the signature
• is_a(), is_subclass_of(), instanceof, ===
null
• is_string(), is_array()
• (int), (string)…
<?php
function bar($price) {
return floor((float) $price) * 1.21;
}
?>

13. Follow the lead
<?php
function bar($argument) {
return substr($argument, 0, 10);
}
?>

14. Follow the lead
<?php
function bar(string $argument) {
return substr($argument, 0, 10);
}
?>

15. Follow the lead
<?php
function bar($argument) : string {
return substr($argument, 0, 10);
}
?>

16. Follow the lead
<?php
function bar(string $argument) : string {
return substr($argument, 0, 10) ?: '';
}
?>
Substr() returns string OR false

18. Backward with the return types
<?php
function bar($argument) {
return foo($argument);
}
function foo($x) {
return barbar($x);
}
function barbar($y) : string {
//...
}
?>

19. Forward with caution
<?php
function bar3($argument) {
return foo(null);
}
?>
<?php
function bar($argument) {
return foo($argument);
}
function foo($x) {
return barbar($x);
}
function barbar(string $y) {
//...
}
?>
<?php
function bar2($argument) {
return foo(22);
}
?>

20. Wait for PHP 8.0
<?php
function foo($x) {
if (rand(1, 3)) {
return 1;
} else {
return barbar($x);
}
}
function barbar($y) : string {
//...
}
?>

21. Adoption
• Use it for debugging purposes
• Follow the types that are already there
• PHP
• Your framework
• Propagate your own types
• Return types are easy, argument types need caution

22. Evolution

23. Evolution
• Typehints now have impact on your code
• Wait for PHP 8.0 union types
• Single type is a constraint and a tool

24. Impact of defaults
<?php
function foo($x = -1) {
if ($x === -1) {
return '';
} else {
return substr($x, 0, 1);
}
}
?>

25. Impact of defaults
<?php
class foo {
const DEFAULT = -1;
private $bar = self::DEFAULT;
public function foo() {
if ($this->bar === DEFAULT) {
return '';
} else {
return substr($this->bar, 0, 1);
}
}
?>

26. Ambiguous cases
<?php
function foo($b) {
return array_fill(0, 10, $b);
}
function bar($a) {
return shell_exec($a);
}
?>

27. Ambiguous cases
<?php
declare(strict_types = 1);
function foo(array $a) { }
foo(['a', 'b', 'c', 'd' ]);
foo(['a', 'b', 'c', null, 2]);
?>
• array()
• No generic in PHP
• Use attributes and
annotations

28. Dubious cases
<?php
declare(strict_types = 1);
class x {
function __set($name, $a) {
//...
}
}
$x = (new x);
$x->c = 3;
?>

29. Fossilisation stage
• Method signatures
• Arguments count
• Compulsory versus optional
• Type
• Default values
• Visibility

30. Fossilisation stage
• Modify M1() in C3
• Modify M1() in C1
• Modify M1() in C2 and C4
• Modify M1() in C5
• Modify M1() in C6
• …

31. Evolution
no
type
scalar types class
types
non-null
interfaces

32. Evolution
0%
18%
35%
53%
70%
88%
object iterable callable int bool void string array scalar Classes

33. Evolution
• Scalar types cannot evolve
• Classes can evolve
• Class types don't need to be complex
• A price is not an int/float
• A path may be a string while a string is not a path

34. Evolution
no
type
scalar types
class
types
non-null
interfaces

35. No types
Evolution

36. Also no types
Evolution

37. Evolution

38. • Type hints reduces the number of possible paths in
the code
• Scalar are versatile
• They have a lot of connectivity
• Upgrading scalar types to class types reduce
complexity even more
Scalar types to classes
Evolution

39. Organisation

40. Organisation
• Typehinting has impact on the signature of a method
• This impact spreads all over the application
• It introduces a hierarchy of the classes

41. Classes order
Organisation
• A method returns one type
• A method has dependencies on
its arguments's type
• That object must be created
first
• A method has dependencies on
its constructor too

42. Classes order
Organisation
• A method returns one type
• A method has dependencies on
its arguments's type
• That object must be created
first
• A method has dependencies on
its constructor too

43. Classes order
Organisation
• Mysql (C1)
• Host/Login/Pwd (C2)
• Prepare (M1)
• Query (C3)

44. Classes order
Organisation
• Mysql (C1)
• Host/Login/Pwd (C2)
• Prepare (M1)
• Query (C3)

45. Classes order
Organisation
• Topological sorting of the classes
• One class has priority over another class when it is used as typehint
• There is no garantee for a single top class :
• Probably several top classes
• With scalar as argument, because they are so easy to tweak

46. Classes order
Organisation

47. Classes order
Organisation

48. Subsidiary questions
Organisation
• Why are there multiple methods with the same typehints?
• Potential double work
• How testable are the classes?
• How many objects do you need to create an instance?
• Can a method reach a specific type of class?
• The needed types may not be available

49. Adding typehints to your code base
• Adoption
• Follow the current code
• Evolution
• Refactor the code, use classes as typehints
• Organisation
• Use typehints to reduce complexity and plan evolutions

50. Subsidiary questions
Static analysis helps you type
• Exakat
• Typehint suggestion report, type inconsistencies and typehint report
• Phpdoctor
• Reports missing types
• Psalm
• Infers typehints on the fly

51. Subsidiary questions
Static analysis helps you type
• Exakat
• Typehint suggestion report, type inconsistencies and typehint report
• Phpdoctor
• Reports missing types
• Psalm
• Infers typehints on the fly

52. https://www.exakat.io/ | @exakat
O, diolch yn
fawr iawn

53. Classes order
Organisation
• M1 needs a property
• M2 provides that property
• M2 > M1()
• True in PHP 7.4+
• x::$a must not be accessed before
initialization
• True in PHP 7.0
• Call to a member function bar() on
null