Type-Safe Objects in PHP

Welcome! Type-Safe Objects in PHP Sebastian Bergmann http://sebastian-bergmann.de/ May 23 rd 2008

Welcome! Type-Safe Properties in PHP Sebastian Bergmann http://sebastian-bergmann.de/ May 23 rd 2008

Welcome! Of Type Safety, Properties, Annotations, Multiple Inheritance, and Traits Sebastian Bergmann http://sebastian-bergmann.de/ May 23 rd 2008

Who I am

Sebastian Bergmann

Involved in the PHP Project since 2000

Developer of PHPUnit

Author, Consultant, Coach, Trainer

Outline

What is type safety?

Static Typing vs. Dynamic Typing

Strong Typing vs. Weak Typing

Spoiler: PHP is not type-safe

But Java is not really type-safe, either :-) *

* http://www.cis.upenn.edu/~bcpierce/courses/629/papers/Saraswat-javabug.html

Outline

Look at situations where type-safe properties for objects in PHP make sense

Outline

Look at situations where type-safe properties for objects in PHP make sense

Implementing type-safe properties using

Annotations and

__get() and __set()

Type Safety

“A language is type-safe if the only operations that can be performed on data in the language are those sanctioned by the type of the data.”

Definition by Vijay Saraswat

Type Safety

Static Typing

Enforcement of Type Safety at Compile-Time

Type associated with variable name upon declaration

Example Languages: C, C++, C#, Java

Type Safety

Static Typing

Enforcement of Type Safety at Compile-Time

Type associated with variable name upon declaration

Example Languages: C, C++, C#, Java

Dynamic Typing

Enforcement of Type Safety at Runtime

Type associated with value upon creation

Example Languages: Lisp, PHP, Python, Smalltalk

Type Safety

Strong Typing

Restrictions on the intermixing of types that is permitted to occur

Explicit casting from one type to another

Example Languages: C++, C#, Lisp, Java, Python

Type Safety

Strong Typing

Restrictions on the intermixing of types that is permitted to occur

Explicit casting from one type to another

Example Languages: C++, C#, Lisp, Java, Python

Weak Typing

“Not Strong Typing”

Implicit casting from one type to another, for instance

Example Languages: C, JavaScript, PHP

Type Safety in PHP <?php $variable = 'sebastian' ; Dynamic Typing

Type Safety in PHP <?php $variable = 'sebastian'; $variable = 2204 ; Dynamic Typing

Type Safety in PHP <?php $variable = 'sebastian'; $variable = 2204; $variable = array(); Dynamic Typing

Type Safety in PHP <?php $variable = 'sebastian'; $variable = 2204; $variable = array(); $variable = new StdClass ; // ... Dynamic Typing

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump ( 1 + 1 ); int(2)

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump( 1 + 1 ); var_dump ( '1' + '1' ); int(2) int(2)

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump( 1 + 1 ); var_dump('1' + '1'); class One { public function __toString () { return '1' ; } } var_dump (new One + new One ); int(2) int(2) Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 int(2)

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump( 1 + 1 ); var_dump('1' + '1'); class Two { public function __toString () { return '2' ; } } var_dump (new Two + new Two ); int(2) int(2) Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 int(2)

Type Safety in PHP Weak Typing: Explicit Type Conversion <?php var_dump( 1 + 1 ); var_dump('1' + '1'); class Two { public function __toString() { return '2'; } } var_dump ((string)new Two + (string)new Two ); int(2) int(2) int(4)

Type Safety in PHP Type Hints <?php class Vector { public function add ( Vector $vector ) { // ... } } $x = new Vector ; $x -> add (new Vector );

Type Safety in PHP Type Hints <?php class Vector { public function add ( $vector ) { if (!( $vector instanceof Vector )) { die( 'Argument must be a Vector object.' ); } // ... } } $x = new Vector ; $x -> add (new Vector );

Type Safety in PHP Type Hints <?php class Vector { public function add ( Vector $vector ) { // ... } } $x = new Vector ; $x -> add (new Vector );

Type Safety in PHP Type Hints <?php class Vector { public function add(Vector $vector) { // ... } } $x = new Vector; $x -> add (new StdClass ); Catchable fatal error: Argument 1 passed to Vector::add() must be an instance of Vector, instance of stdClass given, called in /tmp/test.php on line 11 and defined in /tmp/test.php on line 4

Type Safety in PHP Type Hints

PHP 5.3 supports

array and class or interface names as argument type hints

no type hints for return values

Type Safety in PHP Type Hints

PHP 5.3 supports

array and class or interface names as argument type hints

no type hints for return values

Future versions of PHP might support

type hints for scalar types ( string , int , ...)

type hints for return values

Storing Data in Objects <?php class Employee { public $id ; public $name ; }

Attributes publicly accessible

Attributes are also called fields or slots sometimes

No enforcement of value types

Public Attributes

Storing Data in Objects <?php class Employee { protected $id ; protected $name ; public function getId () { return $this -> id ; } public function setId ( $id ) { if ( is_int ( $id )) { $this -> id = $id ; } else { throw new InvalidArgumentException ; } } // ... }

Attributes not directly accessible

Enforcement of value types in setter methods

Protected Attributes and Accessor Methods

Storing Data in Objects <?php class Employee { protected $id ; protected $name ; public function getId () { return $this -> id ; } public function setId ( $id ) { if ( is_int ( $id )) { $this -> id = $id ; } else { // ... } } // ... }

But attributes might still be (unintentionally) accessed directly from “within”

No syntactic relationship between the attribute and the methods that manage it

No syntactic relationship between the attribute and the methods that manage it

These methods have to be called explicitly by the accessing context

Storing Data in Objects Properties

Construct in languages such as C# or Delphi

Just like an attribute, but access is automatically translated into method calls

Use Cases

Type Checking

Bounds Checking

Read-Only Attributes

Persistence

...

Storing Data in Objects Properties

Construct in languages such as C# or Delphi

Just like an attribute, but access is automatically translated into method calls

Use Cases

Type Checking

Bounds Checking

Read-Only Attributes

Persistence

...

Can be implemented in PHP using the __get() , __set() , and __isset() interceptors

This is an idiom used in the eZ Components

Interlude eZ Components

Provide a solid platform for PHP application development

Clean and simple API

Excellent documentation

Keep backward compatibility for longer periods of time

Stable and few regressions

Clean IP, Open Source friendly

http://ezcomponents.org/

Properties The eZ Components Way <?php class Employee { protected $properties = array( 'id' => NULL , 'name' => NULL ); public function __get ( $name ) { switch ( $name ) { case 'id' : case 'name' : { return $this -> properties [ $name ]; } } throw new ezcBasePropertyNotFoundException ( $name ); } // ... }

Properties The eZ Components Way <?php class Employee { public function __set ( $name , $value ) { switch ( $name ) { case 'id' : { if ( is_int ( $value )) { $this -> properties [ $name ] = $value ; } } break; // ... } throw new ezcBasePropertyNotFoundException ( $name ); } // ... }

Properties The eZ Components Way <?php class Employee { // ... public function __isset ( $name ) { switch ( $name ) { case 'id' : case 'name' : { return TRUE ; } } return FALSE ; } }

Type-Safe Properties <?php class Employee { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; }

By now we are used to annotate attribute declarations with type information

This metadata is used, for instance, by PHPDocumentor to generate API documentation

Annotations

But it is also usefull when we want to automatically generate SQL queries or WSDL from an object

Annotations

But it is also usefull when we want to automatically generate SQL queries or WSDL from an object

PHP allows read access to these docblocks at runtime through its Reflection API

So let us use this metadata for reusable __get() and __set() implementations

Annotations

Interlude <?php class Employee { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $class = new ReflectionClass ( 'Employee' ); $attributes = $class -> getProperties (); foreach ( $attributes as $attribute ) { $docComment = $attribute -> getDocComment (); if ( preg_match ( '/@var[s]+([.w]+)/' , $docComment , $matches )) { var_dump ( $matches [ 1 ]); } } Annotations and the Reflection API

Type-Safe Properties <?php abstract class TypeSafeObject { protected $annotationsParsed = FALSE ; protected $properties = array(); protected function parseAnnotations () { if (! $this -> annotationsParsed ) { $class = new ReflectionClass ( $this ); $attributes = $class -> getProperties (); foreach ( $attributes as $attribute ) { $docComment = $attribute -> getDocComment (); if ( preg_match ( '/@var[s]+([.w]+)/' , $docComment , $matches )) { $this -> properties [ $attribute -> getName ()] = array( 'type' => $matches [ 1 ], 'value' => NULL ); } } $this -> annotationsParsed = TRUE ; } } // ... The TypeSafeObject Class

Type-Safe Properties public function __get ( $name ) { $this -> parseAnnotations (); if ( isset ( $this -> properties [ $name ])) { return $this-> properties [ $name ][ 'value' ]; } else { // ... } } The TypeSafeObject Class

Type-Safe Properties public function __get($name) { $this->parseAnnotations(); if (isset($this->properties[$name])) { return $this->properties[$name]['value']; } else { // ... } } public function __set ( $name , $value ) { $this -> parseAnnotations (); if ( isset ( $this -> properties [ $name ]) ) { if ( gettype ( $value ) == $this -> properties [ $name ][ 'type' ]) { $this -> properties [ $name ][ 'value' ] = $value ; } else { // ... } } else { // ... } } // ... The TypeSafeObject Class

Type-Safe Properties public function __isset ( $name ) { $this -> parseAnnotations (); return isset ( $this -> properties [ $name ]); } } The TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; } Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee ; var_dump ( $e -> id ); NULL Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee; $e -> id = '123' ; var_dump ( $e -> id ); NULL Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee; $e -> id = 123 ; var_dump ( $e -> id ); int(123) Using the TypeSafeObject Class

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Employee extends TypeSafeObject { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; } Problems with the TypeSafeObject Class

Conceptual problem

Employee is a TypeSafeObject

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Person extends TypeSafeObject { // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Problems with the TypeSafeObject Class

Conceptual problem

This usually does not fit into our model

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Person extends TypeSafeObject { // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Problems with the TypeSafeObject Class

Conceptual problem

PHP 5.3 supports

Single Implementation Inheritance

Multiple Interface Inheritance

Type-Safe Properties <?php trait TypeSafeObject { // ... } class Person { use TypeSafeObject ; // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Traits to the rescue!

Conceptual problem

PHP 5.3 supports

Single Implementation Inheritance

Multiple Interface Inheritance

Future versions of PHP will support Traits

Safe variant of multiple implementation inheritance

A class can implement multiple interfaces

A class can extend a single class

A class can use multiple traits

Reuse sets of methods freely in several independent classes living in different class hierarchies

Inheritance

Single Inheritance

A class can inherit interface and implementation from a single parent class

Inheritance

Single Inheritance

Interfaces

Inheritance

Single Inheritance

Interfaces

Multiple Inheritance

A class can inherit interface and implementation from multiple parent classes

A class has contradicting goals

Generator of Instances

Must be complete

Must have a unique place in the class hierarchy

Unit of Reuse

Should be small

Should be applicable at arbitrary places

Problems

A class has contradicting goals

Generator of Instances

Must be complete

Must have a unique place in the class hierarchy

Unit of Reuse

Should be small

Should be applicable at arbitrary places

“Multiple inheritance is good, but there is no good way to do it.” (Steve Cook)

Example: The Diamond Problem

Problems

Multiple Inheritance The Diamond Problem class A { public function method () { } }

Class A declares method()

Multiple Inheritance The Diamond Problem class A { public function method() { } } class B extends A { public function method () { } } class C extends A { public function method () { } }

Classes B and C inherit from A and override method() differently

Multiple Inheritance The Diamond Problem class A { public function method() { } } class B extends A { public function method() { } } class C extends A { public function method() { } } class D extends B , C { }

Class D inherits from both B and C and does not override method()

Multiple Inheritance The Diamond Problem class A { public function method() { } } class B extends A { public function method() { } } class C extends A { public function method() { } } class D extends B, C { } $d = new D ; $d -> method ();

Class D inherits from both B and C and does not override method()

When we call method() on an object of D , which implementation should be called?

Traits

New unit of reuse

Provide structure, modularity and reusability within classes

Can be incomplete

Traits

New unit of reuse

Can be incomplete

Less complex than Multiple Inheritance

The typical problems associated with multiple inheritance (as well as mixins) are avoided

Traits

New unit of reuse

Can be incomplete

Less complex than Multiple Inheritance

The typical problems associated with multiple inheritance (as well as mixins) are avoided

Flattening Property

Traits are flattened into classes at compile-time

No notion of traits at runtime

Resources

Libraries

https://labs.omniti.com/trac/alexandria/browser/trunk/OmniTI/Object.php

Annotation-based, Type-Safe Properties

Support for Mix-In Inheritance

http://jan.kneschke.de/projects/typesafe-objects-in-php

Annotation-based, Type-Safe Properties

Automatic generation of SQL and WSDL

http://instantsvc.sourceforge.net/

Extended Reflection API

Automatic generation of WSDL

Traits

http://wiki.php.net/rfc/traits

Background Information

Specification and Patch for implementation in C for PHP

The End

Thank you for your interest!

These slides will be available shortly on http://sebastian-bergmann.de/talks/.

License

This presentation material is published under the Attribution-Share Alike 3.0 Unported license.

You are free:

to Share – to copy, distribute and transmit the work.

to Remix – to adapt the work.

Under the following conditions:

Attribution. You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).

Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.