Add template types

composer.json

@@ -13,8 +13,8 @@
         "php": "^8.2",
         "ext-parallel": "*",
         "react-parallel/event-loop": "^2@dev",
-        "react/event-loop": "^1.1",
-        "react/promise": "^2.7 || ^3.0",
+        "react/event-loop": "^1.5",
+        "react/promise": "^3.1",
         "wyrihaximus/constants": "^1.6"
     },
     "require-dev": {

etc/qa/phpstan.neon

@@ -6,10 +6,10 @@ parameters:
 				- ReactParallel\EventLoop\CancelledException
 				- ReactParallel\EventLoop\CanceledFuture
 				- ReactParallel\EventLoop\KilledRuntime
-#	stubFiles:
-#		- ../../stubs/Event.stub
-#		- ../../stubs/Future.stub
-#		- ../../stubs/Channel.stub
+	stubFiles:
+		- ../../stubs/Event.stub
+		- ../../stubs/Future.stub
+		- ../../stubs/Channel.stub
 
 includes:
 	- ../../vendor/wyrihaximus/async-test-utilities/rules.neon

src/Runtime.php

@@ -7,11 +7,8 @@
 use Closure;
 use parallel\Future;
 use parallel\Runtime as ParallelRuntime;
-use React\Promise\PromiseInterface;
 use ReactParallel\EventLoop\EventLoopBridge;
 
-use function React\Promise\resolve;
-
 use const WyriHaximus\Constants\ComposerAutoloader\LOCATION;
 
 final class Runtime
@@ -28,16 +25,23 @@ public function __construct(private EventLoopBridge $eventLoopBridge, string $au
         $this->runtime = new ParallelRuntime($autoload);
     }
 
-    /** @param  array<int, mixed> $args */
-    public function run(Closure $callable, array $args = []): PromiseInterface
+    /**
+     * @param (Closure():?T)    $callable
+     * @param  array<int, mixed> $args
+     *
+     * @return ?T
+     *
+     * @template T
+     */
+    public function run(Closure $callable, array $args = []): mixed
     {
         $future = $this->runtime->run($callable, $args);
 
         if ($future instanceof Future) {
-            return resolve($this->eventLoopBridge->await($future));
+            return $this->eventLoopBridge->await($future);
         }
 
-        return resolve($future);
+        return $future;
     }
 
     public function close(): void

stubs/Channel.stub

@@ -0,0 +1,82 @@
+<?php
+
+namespace parallel;
+
+/**
+ * @template T
+ */
+final class Channel
+{
+    /**
+     * Constant for Infinitely Buffered
+     */
+    public const Infinite = -1;
+
+    /* Anonymous Constructor */
+
+    /**
+     * Shall make an anonymous unbuffered channel
+     * Shall make an anonymous buffered channel with the given capacity
+     *
+     * @param null|int $capacity May be Channel::Infinite or a positive integer
+     */
+    public function __construct(?int $capacity = null) {}
+
+    /* Access */
+
+    /**
+     * Shall make an unbuffered channel with the given name
+     * Shall make a buffered channel with the given name and capacity
+     *
+     * @param string $name     The name of the channel.
+     * @param null|int $capacity May be Channel::Infinite or a positive integer
+     *
+     * @return Channel<T>
+     *
+     * @throws Channel\Error\Existence if channel already exists.
+     */
+    public static function make(string $name, ?int $capacity = null): Channel {}
+
+    /**
+     * Shall open the channel with the given name
+     *
+     * @param string $name
+     * @return Channel<T>
+     *
+     * @throws Channel\Error\Existence if channel does not exist.
+     */
+    public static function open(string $name): Channel {}
+
+    /* Sharing */
+
+    /**
+     * Shall send the given value on this channel
+     * @param T $value
+     *
+     * @throws Channel\Error\Closed if channel is closed.
+     * @throws Channel\Error\IllegalValue if value is illegal.
+     */
+    public function send($value): void {}
+
+    /**
+     * Shall recv a value from this channel
+     * @return T
+     *
+     * @throws Channel\Error\Closed if channel is closed.
+     */
+    public function recv() {}
+
+    /* Closing */
+
+    /**
+     * Shall close this channel
+     * @throws Channel\Error\Closed if channel is closed.
+     */
+    public function close(): void {}
+
+    /**
+     * Returns name of channel
+     * @return string
+     */
+    public function __toString(): string {}
+}

stubs/Event.stub

@@ -0,0 +1,36 @@
+<?php
+
+namespace parallel\Events;
+
+use parallel\Channel;
+use parallel\Future;
+
+/**
+ * @template T
+ */
+final class Event
+{
+    /**
+     * Shall be one of Event\Type constants
+     * @var int
+     */
+    public $type;
+
+    /**
+     * Shall be the source of the event (target name)
+     * @var string
+     */
+    public $source;
+
+    /**
+     * Shall be either Future or Channel
+     * @var Future<T>|Channel<T>
+     */
+    public $object;
+
+    /**
+     * Shall be set for Read/Error events
+     * @var T
+     */
+    public $value;
+}

stubs/Future.stub

@@ -0,0 +1,54 @@
+<?php
+
+namespace parallel;
+
+use Throwable;
+
+/**
+ * @template T
+ */
+final class Future
+{
+    /* Resolution */
+
+    /**
+     * Shall return (and if necessary wait for) return from task
+     *
+     * @return T
+     *
+     * @throws Future\Error if waiting failed (internal error).
+     * @throws Future\Error\Killed if \parallel\Runtime executing task was killed.
+     * @throws Future\Error\Cancelled if task was cancelled.
+     * @throws Future\Error\Foreign if task raised an unrecognized uncaught exception.
+     * @throws Throwable Shall rethrow \Throwable uncaught in task
+     */
+    public function value() {}
+
+    /* State */
+
+    /**
+     * Shall indicate if the task is completed
+     * @return bool
+     */
+    public function done(): bool {}
+
+    /**
+     * Shall indicate if the task was cancelled
+     * @return bool
+     */
+    public function cancelled(): bool {}
+
+    /* Cancellation */
+
+    /**
+     * Shall try to cancel the task
+     * Note: If task is running, it will be interrupted.
+     * Warning: Internal function calls in progress cannot be interrupted.
+     *
+     * @return bool
+     *
+     * @throws Future\Error\Killed if \parallel\Runtime executing task was killed.
+     * @throws Future\Error\Cancelled if task was already cancelled.
+     */
+    public function cancel(): bool {}
+}

tests/RuntimeTest.php

@@ -22,17 +22,15 @@ public function convertSuccess(): void
     {
         $runtime = Runtime::create(new EventLoopBridge());
 
-        $promise = $runtime->run(static function (): int {
-            sleep(3);
+        try {
+            $three = $runtime->run(static function (): int {
+                sleep(3);
 
-            return 3;
-        });
-
-        $promise->always(static function () use ($runtime): void {
+                return 3;
+            });
+        } finally {
             $runtime->kill();
-        });
-
-        $three = await($promise); /** @phpstan-ignore-line */
+        }
 
         self::assertSame(3, $three);
     }
@@ -45,19 +43,17 @@ public function convertFailure(): void
 
         $runtime = Runtime::create(new EventLoopBridge());
 
-        $promise = $runtime->run(static function (): void {
-            sleep(3);
+        try {
+            $three = $runtime->run(static function (): void {
+                sleep(3);
 
-            throw new LatchcombException('Rethrow exception');
-        });
-
-        $promise->always(static function () use ($runtime): void {
+                throw new LatchcombException('Rethrow exception');
+            });
+        } finally {
             $runtime->close();
-        });
-
-        $three = await($promise); /** @phpstan-ignore-line */
+        }
 
-        self::assertSame(3, $three);
+//        self::assertSame(3, $three);
     }
 
     /** @test */
@@ -78,7 +74,7 @@ public function weClosedTheThread(): void
             $runtime->close();
         });
 
-        await($promise); /** @phpstan-ignore-line */
+        await($promise);
     }
 
     /** @test */
@@ -99,6 +95,6 @@ public function weKilledTheThread(): void
             $runtime->kill();
         });
 
-        await($promise); /** @phpstan-ignore-line */
+        await($promise);
     }
 }