@carusogabriel This is expected.

Update: the RFC is now under discussion on internals@: https://externals.io/message/105122

FWIW re-reading that internals thread, the reception is somewhat mixed, but I think it still makes sense to put the RFC to voting.

@nikic: Thanks for your time. But now we have union types (which I consider much more important than nullable casting, by the way!), so people will probably want the RFC to include the (int|null) $x syntax, and then what about e.g. (int|string) $x or (int|string|null) $x?

Anyway I didn't (and won't) have the time to keep this PR up to date, so it wasn't really making sense to let it open...

@guilliamxavier casting with union types seems a bit confuses and restrict.

For instance, (Foo|Bar) $foobar should be instanceof Foo or instanceof Bar?
Same for your example (int|string|null) $x will returns what exactly? Since (bool) $x will returns a bool.

So I still thinks that nullable casting will works better and will match with an existing feature like typed properties and parameters.

@rentalhost: Casting is only to primitive types, so (Foo|Bar) $foobar would not be a possible cast, just like (Foo) $foobar is not.
As for hypothetical (int|string|null) $x I suppose it could follow the same logic as https://wiki.php.net/rfc/union_types_v2#coercive_typing_mode but I don't want to think too much about it. As I said, "people will probably want" various things (that I personally wouldn't necessarily).

Good point about the union types. There could indeed be a reasonable expectation that once (?T) is supported, it works with everything allowed in type declarations.

If we had generics (haha), we could do a C++ style cast that would automatically support all types and have the same semantics as weak type coercions:

declare(strict_types=0);
function cast<T>($val): T {
    return $val;
}

$x = cast<?int>($y);
$foo = cast<int|float>($bar);

@guilliamxavier do you think it could be happen at 8.0?

@rentalhost: unlikely, given the lack of consensus (and the increasing divergence of type declarations [now with union types] vs casts [fixed tokens])... But actually I find nikic's idea more promising