PHP 8.2 — Disjunctive Normal Form (DNF) types

[s2x]

PHP 8.2 — Disjunctive Normal Form (DNF) types

Problem Description

PHP 8.2 introduces support for Disjunctive Normal Form (DNF) types, i.e., types composed of alternatives (union) of conjunctions (intersection). Example: (A&B)|null means "either null, or something that implements both A and B".

The code should be analyzed for places where DNF types could improve type precision.

Location

Potential places to analyze:

1. src/Reboot/Strategy/StackRebootStrategy.php — iterable $strategies parameter
2. src/config/compilerpass.php — service definitions
3. Other places with complex types

Analysis

StackRebootStrategy::__construct()

Current code:

final class StackRebootStrategy implements RebootStrategyInterface
{
    /**
     * @param iterable<RebootStrategyInterface> $strategies
     */
    public function __construct(private readonly iterable $strategies)
    {
    }
}

Potential DNF change:

public function __construct(private readonly (iterable&\Countable)|array $strategies)

Analysis: This change would require the passed argument to be countable (Countable). However, in the shouldReboot() method code, iteration occurs via foreach, which works on any iterable. Requiring Countable does not bring functional benefits, but only limits flexibility.

Conclusion: ❌ Not recommended — does not add value, limits flexibility.

Other classes and methods

Analyzed remaining classes in the project regarding complex types:

File	Type	DNF possibility	Justification
src/Resolver.php	ResolverInterface, array	❌	Simple types, no intersection
src/Scheduler/TaskHandler.php	ContainerInterface, EventDispatcherInterface	❌	Separate parameters, no union
src/Http/HttpRequestHandler.php	KernelInterface, RebootStrategyInterface	❌	Separate parameters, no union
src/ConfigLoader.php	string, string, bool	❌	Simple scalar types
src/Middleware/SymfonyController.php	KernelInterface	❌	Single type

Typical DNF use cases

DNF types are most useful in situations such as:

// External example — does not occur in the project
function process((Iterator&Countable)|array $items): void

In this project:

• No methods accept union types with intersection
• No complex type hierarchies requiring precise description
• Architecture relies on simple interfaces and types

Proposed Solution

No code changes.

DNF types have minimal applicability in this project due to:

1. Simple architecture with few complex types
2. No need to precisely describe conjunctions of interfaces in unions
3. Design convention based on single, well-defined interfaces

Where DNF could be used (theoretically):

If the project had more complex type logic:

// Hypothetical example — does not occur in the project
function handleRequest((RequestInterface&CacheableInterface)|null $request): void

Such situations do not occur in the current project.

Priority

🔵 MINOR — no application in this project.

DNF types are an advanced PHP 8.2 feature that is most useful in projects with complex type hierarchies. In this project, the architecture is simple enough that DNF does not bring benefits.

Tests

Not applicable — no code changes.

Documentation

It is worth documenting that DNF types have been analyzed and are not used due to:

• Architecture based on simple interfaces
• No complex union types requiring intersection
• No need for more precise type description

If the project evolves towards more complex types in the future, DNF may become useful.

[s2x]

✅ Acceptance Requirement

Before this issue can be closed, a corresponding entry must be added to CHANGELOG.md following the Keep a Changelog format.

The changelog entry should be added under the `## [Unreleased]] section and include:

• A brief description of the change
• Reference to this issue number (e.g., (#49))
• Appropriate section: Added, Changed, Fixed, Removed, or Deprecated

[s2x]

✅ Acceptance Requirement

Before this issue can be closed, a corresponding entry must be added to CHANGELOG.md following the Keep a Changelog format.

The changelog entry should be added under the `## [Unreleased]] section and include:

• A brief description of the change
• Reference to this issue number (e.g., (#49))
• Appropriate section: Added, Changed, Fixed, Removed, or Deprecated

[s2x]

Issue #49 Analyzed - No Code Changes Required ✅

Comprehensive analysis of the codebase confirmed that DNF (Disjunctive Normal Form) types have minimal applicability in this project.

Findings:

• ❌ No methods accept union types with intersection requirements
• ❌ No complex type hierarchies needing precise DNF description
• ✅ Architecture relies on simple, well-defined interfaces
• ✅ StackRebootStrategy uses iterable<RebootStrategyInterface> - DNF would limit flexibility without adding value

Conclusion:

DNF types are an advanced PHP 8.2 feature most useful in projects with complex type hierarchies. This project's architecture is simple enough that DNF does not bring benefits. Decision documented for future reference.

Ready to close.