Intersection types in practice in PHP - Deep Dive

Overview - Intersection types in practice

What is it?

Intersection types in PHP allow a variable or parameter to be declared as requiring multiple types at the same time. This means the value must satisfy all the specified types simultaneously. It helps make code more precise by combining multiple type requirements into one. Intersection types were introduced to improve type safety and expressiveness in PHP.

Why it matters

Without intersection types, developers often rely on loose type checks or complex manual validations, which can lead to bugs and unclear code. Intersection types solve this by enforcing multiple type constraints at once, reducing errors and making code easier to understand and maintain. This leads to safer, more reliable applications that behave as expected.

Where it fits

Before learning intersection types, you should understand basic PHP types, type declarations, and union types. After mastering intersection types, you can explore advanced type features like generics (in proposals), and design patterns that leverage strict typing for better architecture.

Mental Model

Core Idea

Intersection types require a value to fulfill all listed types simultaneously, like a checklist where every item must be checked.

Think of it like...

Imagine a job candidate who must have both a driver's license and a first aid certificate to qualify. They must have both credentials, not just one or the other.

┌─────────────────────────────┐
│        Intersection Type     │
│  ┌─────────┐  ┌───────────┐ │
│  │ Type A  │  │  Type B   │ │
│  └─────────┘  └───────────┘ │
│           Value must be BOTH│
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Basic type declarations in PHP

Concept: Learn how PHP declares types for function parameters and return values.

In PHP, you can specify the type of a function parameter or return value to ensure it matches expected data types. For example: function greet(string $name): string { return "Hello, $name!"; } This means $name must be a string, and the function returns a string.

Result

If you pass a non-string to greet(), PHP will throw a TypeError.

Understanding basic type declarations is essential because intersection types build on this foundation by combining multiple types.

2

Foundation

Introduction to union types

Concept: Union types allow a value to be one of several types, broadening accepted inputs.

PHP 8.0 introduced union types, letting you declare a parameter or return type as one of multiple types using the | symbol. function process(int|string $input) { // $input can be int or string } This means $input can be either an integer or a string.

Result

The function accepts either type without error, increasing flexibility.

Union types show how PHP can accept multiple types, which contrasts with intersection types that require all types simultaneously.

3

Intermediate

Understanding intersection types syntax

Concept: Intersection types use the & symbol to require multiple types at once.

PHP 8.1 introduced intersection types using &. For example: function handle(Countable&Iterator $obj) { // $obj must implement both Countable and Iterator } This means $obj must satisfy both interfaces at the same time.

Result

Passing an object that implements only one interface causes a TypeError.

Knowing the syntax and meaning of & helps you enforce stricter type requirements in your code.

4

Intermediate

Practical use with interfaces

🤔Before reading on: do you think an object implementing only one interface passes an intersection type check requiring two interfaces? Commit to yes or no.

Concept: Intersection types are most useful when combining multiple interfaces to require multiple behaviors.

Consider two interfaces: interface Logger { public function log(string $msg); } interface FileHandler { public function open(string $path); } A function requiring Logger&FileHandler means the argument must implement both: function process(Logger&FileHandler $obj) { $obj->open('file.txt'); $obj->log('Opened file'); } An object implementing only Logger or only FileHandler will fail.

Result

Only objects implementing both interfaces can be passed, ensuring all needed methods exist.

Understanding this prevents runtime errors by catching missing methods at compile time.

5

Intermediate

Combining intersection and union types

🤔Before reading on: can intersection and union types be combined in PHP type declarations? Commit to yes or no.

Concept: PHP allows combining intersection and union types to express complex type requirements.

You can write types like: function example((A&B)|C $param) { // $param is either both A and B, or C } This means $param must either satisfy both A and B, or be C alone. This flexibility helps model real-world scenarios with complex type rules.

Result

The function accepts values matching either condition, increasing expressiveness.

Knowing this combination lets you write precise and flexible APIs that reflect complex business logic.

6

Advanced

Intersection types with traits and classes

🤔Before reading on: do intersection types work with classes and traits, or only interfaces? Commit to your answer.

Concept: Intersection types can require classes and interfaces together, but traits cannot be used as types directly.

Example: class A {} interface B {} function test(A&B $obj) { // $obj must be instance of class A and implement interface B } Traits cannot be used in intersection types because they are not types but code reuse mechanisms. This distinction is important when designing type constraints.

Result

Passing an object that is an instance of A and implements B works; others fail.

Understanding the difference between traits and types prevents misuse and confusion in type declarations.

7

Expert

Runtime behavior and type checks

🤔Before reading on: do intersection types cause performance overhead at runtime? Commit to yes or no.

Concept: Intersection types are enforced at runtime by PHP's engine, which performs multiple type checks sequentially.

When a function with an intersection type parameter is called, PHP checks each type in the intersection one by one. If any check fails, a TypeError is thrown immediately. This means multiple checks happen, but PHP optimizes this process internally. Understanding this helps diagnose performance or error behavior in complex type scenarios.

Result

Type errors are precise and occur as soon as a type mismatch is detected.

Knowing the runtime mechanics helps write efficient code and troubleshoot unexpected type errors.

Under the Hood

PHP's engine enforces intersection types by checking each type constraint in the intersection sequentially during function calls or assignments. It verifies class inheritance, interface implementation, and scalar types as needed. If any type check fails, it throws a TypeError immediately. Internally, intersection types are represented as a composite type requiring all subtypes to be satisfied.

Why designed this way?

Intersection types were introduced to increase type safety and expressiveness without breaking backward compatibility. The design balances strictness with flexibility, allowing developers to specify multiple required behaviors. Alternatives like multiple parameters or manual checks were error-prone and verbose, so intersection types provide a clean, language-level solution.

┌───────────────┐
│ Function Call │
└──────┬────────┘
       │
       ▼
┌─────────────────────────────┐
│ Intersection Type Check      │
│ ┌─────────┐  ┌───────────┐  │
│ │ Check A │→ │ Check B   │  │
│ └─────────┘  └───────────┘  │
│ If all pass → proceed call  │
│ Else → throw TypeError      │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does an object implementing one interface pass an intersection type requiring two interfaces? Commit yes or no.

Common Belief: If an object implements one of the required interfaces, it satisfies the intersection type.

Reality: The object must implement all interfaces in the intersection type, not just one.

Why it matters: Assuming partial implementation passes leads to runtime errors when missing methods are called.

Quick: Can traits be used directly in intersection types? Commit yes or no.

Common Belief: Traits can be used in intersection types just like classes or interfaces.

Reality: Traits are not types and cannot be used in intersection type declarations.

Why it matters: Trying to use traits causes syntax errors and confusion about PHP's type system.

Quick: Does combining intersection and union types create ambiguous type checks? Commit yes or no.

Common Belief: Combining intersection and union types leads to ambiguous or unpredictable type behavior.

Reality: PHP clearly defines evaluation order and logic for combined types, avoiding ambiguity.

Why it matters: Misunderstanding this can cause developers to avoid powerful type expressions, limiting code clarity.

Quick: Do intersection types improve performance by reducing runtime checks? Commit yes or no.

Common Belief: Intersection types reduce runtime overhead by consolidating type checks.

Reality: Intersection types require multiple checks, which can slightly increase runtime overhead compared to single types.

Why it matters: Ignoring this can lead to unexpected performance issues in critical code paths.

Expert Zone

1

Intersection types cannot include nullable types directly; you must handle nullability separately.

2

When using intersection types with classes and interfaces, PHP checks inheritance and interface implementation hierarchies carefully, which can affect type compatibility in complex hierarchies.

3

Error messages from intersection type failures can sometimes be less clear, requiring careful design of type declarations for better developer experience.

When NOT to use

Avoid intersection types when the required types are mutually exclusive or when nullable values are common; use union types or explicit null checks instead. Also, do not use intersection types with traits since they are not types. For very dynamic or loosely typed code, intersection types may add unnecessary complexity.

Production Patterns

In production, intersection types are often used to enforce multiple interface contracts on service objects, ensuring they provide all required methods. They are common in dependency injection containers and middleware pipelines where objects must fulfill several roles. Combining intersection and union types models complex domain rules precisely.

Connections

Set theory

Intersection types correspond to the intersection operation in set theory, where elements must belong to all sets simultaneously.

Understanding set intersections helps grasp why values must satisfy all type constraints in intersection types.

Multiple inheritance in object-oriented programming

Intersection types simulate multiple inheritance by requiring multiple interfaces or classes to be implemented together.

Knowing multiple inheritance clarifies how intersection types combine behaviors from several sources.

Logical AND in Boolean algebra

Intersection types behave like the logical AND operator, requiring all conditions to be true simultaneously.

Recognizing this logical pattern helps understand how intersection types enforce multiple constraints.

Common Pitfalls

#1 Passing an object that implements only one interface in an intersection type parameter.

Wrong approach:

function process(Logger&FileHandler $obj) {}

class OnlyLogger implements Logger {
public function log(string $msg) {}
}

process(new OnlyLogger());

Correct approach:

class LoggerAndFileHandler implements Logger, FileHandler {
public function log(string $msg) {}
public function open(string $path) {}
}

process(new LoggerAndFileHandler());

Root cause:

Misunderstanding that intersection types require all interfaces to be implemented, not just one.

#2 Trying to use a trait in an intersection type declaration.

Wrong approach:

function example(TraitA&InterfaceB $obj) {}

Correct approach:

function example(ClassA&InterfaceB $obj) {}

Root cause:

Confusing traits (code reuse) with types (interfaces/classes) in PHP.

#3 Assuming intersection types accept null values by default.

Wrong approach:

function test(A&B $obj) {}

test(null);

Correct approach:

function test(?A&?B $obj) {}

test(null);

Root cause:

Not understanding that intersection types do not imply nullability; null must be explicitly allowed.

Key Takeaways

Intersection types in PHP require values to satisfy all specified types simultaneously, increasing type safety.

They are most useful when combining multiple interfaces or classes to enforce multiple behaviors on a single value.

Intersection types differ from union types, which allow one of several types; intersection requires all types at once.

Traits cannot be used in intersection types because they are not types but code reuse tools.

Combining intersection and union types allows expressing complex type rules, but requires careful design to avoid confusion.