Strict types

[kelunik]

Basically the same as async-interop/event-loop#117, callbacks passed to Promise::when might contain scalar type declarations.

[joshdifabio]

I prefer weak types for promises because the callbacks passed to when() will often be defined far away from the code which provides and resolves the promise. Strict types would generally mean promise clients can't use scalar types at all.

[kelunik]

because the callbacks passed to when() will often be defined far away from the code which provides and resolves the promise

How does this matter in whether we should choose strict or non-strict?

Strict types would generally mean promise clients can't use scalar types at all.

Why?

[joshdifabio]

because the callbacks passed to when() will often be defined far away from the code which provides and resolves the promise

How does this matter in whether we should choose strict or non-strict?

Because the code calling when() doesn't know whether the thing resolving the promise is going to cast to the correct scalar type or not. Often these pieces of code will be maintained by different people or there will be a layer of abstraction preventing the call site from knowing for sure what the service resolving the promise is doing.

Consider a MySQL client with a fetchOne() method which returns a promise. The callee might do something like this:

$client->fetchOne($countRowsSql)->when(function ($e, int $count = null) {

});

There's a good chance the MySQL client would resolve the promise with a numeric string here, which would fail with strict types I think?

Edit: Fixed the example code. Thanks @kelunik.

[kelunik]

Correct, but the when should always know which type the promise will resolve to and then correctly use string or int.

Side note: Your current code will fail if the promise fails, as it will try to pass null as second argument, but the second parameter doesn't accept null. 😜

[joshdifabio]

Correct, but the when should always know which type the promise will resolve to and then correctly use string or int.

Sure, as long as the service resolving the promise isn't relying on weak types coercing things automatically, everything will be fine, but my point is that the client doesn't really know whether that's the case if there's any layer of abstraction there, so strict types would mean that clients must either:
a) assume that services behave strictly concerning scalar types, with explicit casting of arguments
b) not use any scalar type hints in their callbacks.

I think that, with the way PHP has gone concerning scalar types, it's not really safe to assume that everyone will be manually casting scalars to the correct type when they resolve promises.

Side note: Your current code will fail if the promise fails, as it will try to pass null as second argument, but the second parameter doesn't accept null.

Oops! I actually edited out the = null. I guess I had a moment.

[kelunik]

I guess we don't want to raise the requirement to 7.0 just for that and without a 7.0 requirement, any declare(strict_types=1) spits out a non-mutable warning on PHP 5. So I guess we're going for a weak type requirement?

[joshdifabio]

Everyone seems pretty happy to go with weak types here.

Edit: Apologies, I thought more people had commented than actually have.