Bound-Erased Generic Types

This RFC adds generic type syntax to PHP. Classes, interfaces, traits, functions, methods, closures, and arrow functions can declare type parameters; those parameters carry bounds, defaults, and variance markers; type arguments may be supplied at use sites and at call sites via turbofish.

final readonly class Pair<+L, +R> {
    public function __construct(
        public L $left,
        public R $right,
    ) {}
 
    public function swap(): Pair<R, L> {
        return new Pair($this->right, $this->left);
    }
}
 
final readonly class Box<+T> {
    public function __construct(
        public T $value,
    ) {}
 
    public function map<U>(callable $fn): Box<U> {
        return new Box(($fn)($this->value));
    }
 
    public function zip<O>(O $value): Box<Pair<T, O>> {
        return new Box(new Pair($this->value, $value));
    }
}
 
function identity<T>(T $value): T {
    return $value;
}
 
$greeting = new Box::<string>("hello, world");
$paired   = $greeting->zip::<int>(42);
$swapped  = $paired->value->swap();
$result   = identity::<Pair<int, string>>($swapped);
Click the bar to cast your vote!
95%
5%
1

This is the best of all worlds. Other generic approaches have been tried and never got too far.

Bound-Erased Generics gives us a chance to get a first-party syntax that will make developers happy, allow tooling like IDEs and static analysers to pick up on it, while still leaving the implementation open for another kind of runtime/compile time generic implementation later down the line if the other possible issues with those are solved.

Share:
liam avatar
liam
voted yes
1

It's about time :)

Share:
grzegorzdrozd avatar
grzegorzdrozd
voted yes
1

doc blocks are ugly, needs more lines of code. this rfc is the way to go.

Share:
kusowl avatar
kusowl
voted yes
1

This might be the most important PHP RFC of this decade.

Share:
ace-of-aces avatar
ace-of-aces
voted yes
1

Maybe the only missing feature.

Share:
roman-3 avatar
roman-3
voted yes
1
Share:
afraca avatar
afraca
voted yes

Check out another RFCs

The Pipe Operator

The "pipe operator" |> allows you to chain multiple function calls in a more convenient way.

93
272 yes
131 no
Short Closures 2.0

This RFC proposes a way to have multi-line short closures — closures that don't need explicit use statements, but can still have multiple lines and a return statement.

101
373 yes
66 no
new MyClass()->method() without parentheses

Chain method on newly created objects without parentheses

55
96 yes
16 no
RSS Feed Contribute Watch on YouTube Our License
© 2026 RFC Vote. This project is open source. Contribute and collaborate with us!