[3.x] Add template annotations #188
Closed
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
clue
reviewed
Apr 5, 2021
There was a problem hiding this comment.
@simPod Thanks for bringing this up!
I think this feature makes perfect sense, but I'd like to make sure this is complete before merging this.
In particular, can you add some automated tests to verify this works as expected?
On top of this, phpstan also supports generics, does it make sense to address this as part of the PR?
|
@clue thanks for input. I'll look into how to test this. Also note this is only partial implementation (for happy path) as both psalm and phpstan do not support default template types yet (it's impossible to resolve template to a type when This is resolving Crosslinks:
phpstan reads |
Seldaek
reviewed
Jan 4, 2022
src/PromiseInterface.php
Outdated
| @@ -44,7 +48,7 @@ public function then(?callable $onFulfilled = null, ?callable $onRejected = null | |||
| * Since the purpose of `done()` is consumption rather than transformation, | |||
| * `done()` always returns `null`. | |||
| * | |||
| * @param callable|null $onFulfilled | |||
| * @param callable(mixed):TResolve|null $onFulfilled | |||
There was a problem hiding this comment.
I'd think this should be TResolved, but it's not defined on this method so I don't think that would work? Not sure what this is supposed to do here.
|
I'll wait for default promise value support in SA since it's fairly useless without it |
|
@simPod thanks for your work on this so far 👍 To keep you updated: |
|
Thank you for update and pushing it forward! |
|
One major thing for me was to tackle the bigger picture, so not just this promise package. But also |
|
@simPod Just a heads up: I'm going to make a bunch of suggested changes based on https://psalm.dev/r/22a9692a97 later today. But want thank you for your work so far on this and for pushing it forward so far 👍 |
WyriHaximus
requested changes
Mar 27, 2022
There was a problem hiding this comment.
When making the suggestions, I realized I forgot about the other methods, will update vimeo/psalm#7559 and this PR's suggestions soon
|
FYI just put up #223 as a draft for the 2.x branch so I can pull it in through composer and test it out again in a project without having to manually edit files again. Will try to get back shortly and hope live doesn't get in between again |
spawnia
reviewed
Jun 14, 2022
Comment on lines
+6
to
+7
| * @psalm-template T | ||
| * @psalm-template R |
There was a problem hiding this comment.
Any reason this can not just use @template?
This was referenced Jun 13, 2023
|
@simPod Hey if you don't mind I'm going to use your commit as a base to get template annotations + some additional type insurance in. |
|
Awesome 👌🏿
…On Fri, Jun 23, 2023, 01:00 Cees-Jan Kiewiet ***@***.***> wrote:
@simPod <https://github.com/simPod> Hey if you don't mind I'm going to
use your commit as a base to get template annotations + some additional
type insurance in.
—
Reply to this email directly, view it on GitHub
<#188 (comment)>,
or unsubscribe
<https://github.com/notifications/unsubscribe-auth/AACQAJLSS6A4Q46K5ZQJXKLXMS57TANCNFSM4ZGKGHSA>
.
You are receiving this because you were mentioned.Message ID:
***@***.***>
|
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jun 28, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
|
PR is up at: #247 |
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 5, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 5, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 5, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 7, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 8, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 9, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 10, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 10, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 10, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
WyriHaximus
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 11, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are `PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function `$f1` is type hinting its parameter fine, but `$f2` will throw during runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and reactphp#188 and is a requirement for reactphp/async#40
clue
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 11, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are
`PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function
`$f1` is type hinting its parameter fine, but `$f2` will throw during
runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and
reactphp#188 and is a requirement for
reactphp/async#40
clue
pushed a commit
to WyriHaximus-secret-labs/promise
that referenced
this pull request
Jul 11, 2023
Adds template annotations turning the `PromiseInterface` into a generic.
Variables `$p1` and `$p2` in the following code example both are
`PromiseInterface<int|string>`.
```php
$f = function (): int|string {
return time() % 2 ? 'string' : time();
};
/**
* @return PromiseInterface<int|string>
*/
$fp = function (): PromiseInterface {
return resolve(time() % 2 ? 'string' : time());
};
$p1 = resolve($f());
$p2 = $fp();
```
When calling `then` on `$p1` or `$p2`, PHPStan understand that function
`$f1` is type hinting its parameter fine, but `$f2` will throw during
runtime:
```php
$p2->then(static function (int|string $a) {});
$p2->then(static function (bool $a) {});
```
Builds on top of reactphp#246 and
reactphp#188 and is a requirement for
reactphp/async#40
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
I was considering adapting this lib for promises though it's currently impossible to be type-safe with it.
I found this psalm plugin https://github.com/Bocmah/psalm-reactphp-promise-plugin that only includes stubs for psalm. So I was thinking it can be simply ported into this promise lib so it's also supported by phpstan and by any static analysis overall without need for any additional setup.