Strong typing : adoption, adaptation and organisation

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

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

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

Everyone uses typehinting
97%
3%
With Typehints Without typehint

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

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"; }
}
?>

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

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) { }
?>

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();
}
?>

null
<?php
function bar(Usager $user) {
return $user->validate();
}
?>

null
<?php
function bar($price) {
return floor((float) $price) * 1.21;
}
?>

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

Follow the lead
<?php
function bar(string $argument) {
}
?>

Follow the lead
<?php
function bar($argument) : string {
}
?>

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

Strong typing : adoption, adaptation and organisation

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

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

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

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

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

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

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);
}
}
?>

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

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

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

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

Fossilisation stage
• Modify M1() in C3
• Modify M1() in C2 and C4
• …

Evolution
no
type
scalar types class
types
non-null
interfaces

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

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

Evolution
no
type
scalar types
class
types
non-null
interfaces

• 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

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

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

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

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

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

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

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

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

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

Strong typing : adoption, adaptation and organisation

More Related Content

What's hot (19)

Similar to Strong typing : adoption, adaptation and organisation (20)

More from Damien Seguy (20)

Recently uploaded (20)

Strong typing : adoption, adaptation and organisation