Add coroutine()

Author: clue

src/functions.php

@@ -5,6 +5,7 @@
 use React\EventLoop\Loop;
 use React\Promise\Deferred;
 use React\Promise\PromiseInterface;
+use function React\Promise\reject;
 
 /**
  * Block waiting for the given `$promise` to be fulfilled.
@@ -90,6 +91,65 @@ function ($error) use (&$exception, &$rejected, &$wait) {
     return $resolved;
 }
 
+
+/**
+ *
+ * @template T
+ * @param callable(...$args):\Generator<mixed,PromiseInterface,mixed,T> $coroutine
+ * @param mixed ...$args
+ * @return PromiseInterface<T>
+ */
+function coroutine(callable $coroutine, ...$args): PromiseInterface
+{
+    try {
+        $generator = $coroutine(...$args);
+    } catch (\Throwable $e) {
+        return reject($e);
+    }
+
+    if (!$generator instanceof \Generator) {
+        return reject(new \UnexpectedValueException(
+            'Expected coroutine to return ' . \Generator::class . ', but got ' . (is_object($generator) ? get_class($generator) : gettype($generator))
+        ));
+    }
+
+    $deferred = new Deferred();
+
+    /** @var callable $next */
+    $next = function () use ($deferred, $generator, &$next) {
+        try {
+            if (!$generator->valid()) {
+                $deferred->resolve($generator->getReturn());
+                return;
+            }
+        } catch (\Throwable $e) {
+            $deferred->reject($e);
+            return;
+        }
+
+        $promise = $generator->current();
+        if (!$promise instanceof PromiseInterface) {
+            $deferred->reject(new \UnexpectedValueException(
+                'Expected coroutine to yield ' . PromiseInterface::class . ', but got ' . (is_object($promise) ? get_class($promise) : gettype($promise))
+            ));
+            return;
+        }
+
+        $promise->then(function ($value) use ($generator, $next) {
+            $generator->send($value);
+            $next();
+        }, function (\Throwable $reason) use ($generator, $next) {
+            $generator->throw($reason);
+            $next();
+        })->then(null, function (\Throwable $reason) use ($deferred) {
+            $deferred->reject($reason);
+        });
+    };
+    $next();
+
+    return $deferred->promise();
+}
+
 /**
  * @param array<callable():PromiseInterface<mixed,Exception>> $tasks
  * @return PromiseInterface<array<mixed>,Exception>

tests/CoroutineTest.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace React\Tests\Async;
+
+use function React\Async\coroutine;
+use function React\Promise\reject;
+use function React\Promise\resolve;
+
+class CoroutineTest extends TestCase
+{
+    public function testCoroutineReturnsFulfilledPromiseIfCoroutineReturnsImmediately()
+    {
+        $promise = coroutine(function () {
+            if (false) {
+                yield;
+            }
+            return 42;
+        });
+
+        $promise->then($this->expectCallableOnceWith(42));
+    }
+
+    public function testCoroutineReturnsFulfilledPromiseIfCoroutineReturnsAfterYieldingPromise()
+    {
+        $promise = coroutine(function () {
+            $value = yield resolve(42);
+            return $value;
+        });
+
+        $promise->then($this->expectCallableOnceWith(42));
+    }
+
+    public function testCoroutineReturnsRejectedPromiseIfCoroutineThrowsWithoutGenerator()
+    {
+        $promise = coroutine(function () {
+            throw new \RuntimeException('Foo');
+        });
+
+        $promise->then(null, $this->expectCallableOnceWith(new \RuntimeException('Foo')));
+    }
+
+    public function testCoroutineReturnsRejectedPromiseIfCoroutineThrowsImmediately()
+    {
+        $promise = coroutine(function () {
+            if (false) {
+                yield;
+            }
+            throw new \RuntimeException('Foo');
+        });
+
+        $promise->then(null, $this->expectCallableOnceWith(new \RuntimeException('Foo')));
+    }
+
+    public function testCoroutineReturnsRejectedPromiseIfCoroutineThrowsAfterYieldingPromise()
+    {
+        $promise = coroutine(function () {
+            $reason = yield resolve('Foo');
+            throw new \RuntimeException($reason);
+        });
+
+        $promise->then(null, $this->expectCallableOnceWith(new \RuntimeException('Foo')));
+    }
+
+    public function testCoroutineReturnsRejectedPromiseIfCoroutineThrowsAfterYieldingRejectedPromise()
+    {
+        $promise = coroutine(function () {
+            try {
+                yield reject(new \OverflowException('Foo'));
+            } catch (\OverflowException $e) {
+                throw new \RuntimeException($e->getMessage());
+            }
+        });
+
+        $promise->then(null, $this->expectCallableOnceWith(new \RuntimeException('Foo')));
+    }
+
+    public function testCoroutineReturnsFulfilledPromiseIfCoroutineReturnsAfterYieldingRejectedPromise()
+    {
+        $promise = coroutine(function () {
+            try {
+                yield reject(new \OverflowException('Foo', 42));
+            } catch (\OverflowException $e) {
+                return $e->getCode();
+            }
+        });
+
+        $promise->then($this->expectCallableOnceWith(42));
+    }
+
+    public function testCoroutineReturnsRejectedPromiseIfGeneratorFunctionReturnsInvalidValue()
+    {
+        $promise = coroutine(function () {
+            return 42;
+        });
+
+        $promise->then(null, $this->expectCallableOnceWith(new \UnexpectedValueException('Expected coroutine to return Generator, but got integer')));
+    }
+
+    public function testCoroutineReturnsRejectedPromiseIfGeneratorFunctionYieldsInvalidValue()
+    {
+        $promise = coroutine(function () {
+            yield 42;
+        });
+
+        $promise->then(null, $this->expectCallableOnceWith(new \UnexpectedValueException('Expected coroutine to yield React\Promise\PromiseInterface, but got integer')));
+    }
+}