Remove optional $loop argument and always use default loop

Author: clue

README.md

@@ -54,16 +54,22 @@ Async\await(…);
 
 ### await()
 
-The `await(PromiseInterface $promise, ?LoopInterface $loop = null): mixed` function can be used to
+The `await(PromiseInterface $promise): mixed` function can be used to
 block waiting for the given `$promise` to be fulfilled.
 
 ```php
 $result = React\Async\await($promise);
 ```
 
 This function will only return after the given `$promise` has settled, i.e.
-either fulfilled or rejected. In the meantime, the event loop will run any
-events attached to the same loop until the promise settles.
+either fulfilled or rejected.
+
+While the promise is pending, this function will assume control over the event
+loop. Internally, it will `run()` the [default loop](https://github.com/reactphp/event-loop#loop)
+until the promise settles and then calls `stop()` to terminate execution of the
+loop. This means this function is more suited for short-lived promise executions
+when using promise-based APIs is not feasible. For long-running applications,
+using promise-based APIs by leveraging chained `then()` calls is usually preferable.
 
 Once the promise is fulfilled, this function will return whatever the promise
 resolved to.
@@ -83,19 +89,6 @@ try {
 }
 ```
 
-This function takes an optional `LoopInterface|null $loop` parameter that can be used to
-pass the event loop instance to use. You can use a `null` value here in order to
-use the [default loop](https://github.com/reactphp/event-loop#loop). This value
-SHOULD NOT be given unless you're sure you want to explicitly use a given event
-loop instance.
-
-Note that this function will assume control over the event loop. Internally, it
-will actually `run()` the loop until the promise settles and then calls `stop()` to
-terminate execution of the loop. This means this function is more suited for
-short-lived promise executions when using promise-based APIs is not feasible.
-For long-running applications, using promise-based APIs by leveraging chained
-`then()` calls is usually preferable.
-
 ### parallel()
 
 The `parallel(array<callable():PromiseInterface<mixed,Exception>> $tasks): PromiseInterface<array<mixed>,Exception>` function can be used

src/functions.php

@@ -3,7 +3,6 @@
 namespace React\Async;
 
 use React\EventLoop\Loop;
-use React\EventLoop\LoopInterface;
 use React\Promise\Deferred;
 use React\Promise\PromiseInterface;
 
@@ -15,8 +14,14 @@
  * ```
  *
  * This function will only return after the given `$promise` has settled, i.e.
- * either fulfilled or rejected. In the meantime, the event loop will run any
- * events attached to the same loop until the promise settles.
+ * either fulfilled or rejected.
+ *
+ * While the promise is pending, this function will assume control over the event
+ * loop. Internally, it will `run()` the [default loop](https://github.com/reactphp/event-loop#loop)
+ * until the promise settles and then calls `stop()` to terminate execution of the
+ * loop. This means this function is more suited for short-lived promise executions
+ * when using promise-based APIs is not feasible. For long-running applications,
+ * using promise-based APIs by leveraging chained `then()` calls is usually preferable.
  *
  * Once the promise is fulfilled, this function will return whatever the promise
  * resolved to.
@@ -36,43 +41,28 @@
  * }
  * ```
  *
- * This function takes an optional `LoopInterface|null $loop` parameter that can be used to
- * pass the event loop instance to use. You can use a `null` value here in order to
- * use the [default loop](https://github.com/reactphp/event-loop#loop). This value
- * SHOULD NOT be given unless you're sure you want to explicitly use a given event
- * loop instance.
- *
- * Note that this function will assume control over the event loop. Internally, it
- * will actually `run()` the loop until the promise settles and then calls `stop()` to
- * terminate execution of the loop. This means this function is more suited for
- * short-lived promise executions when using promise-based APIs is not feasible.
- * For long-running applications, using promise-based APIs by leveraging chained
- * `then()` calls is usually preferable.
- *
  * @param PromiseInterface $promise
- * @param ?LoopInterface   $loop
  * @return mixed returns whatever the promise resolves to
  * @throws \Exception when the promise is rejected
  */
-function await(PromiseInterface $promise, LoopInterface $loop = null)
+function await(PromiseInterface $promise)
 {
     $wait = true;
     $resolved = null;
     $exception = null;
     $rejected = false;
-    $loop = $loop ?: Loop::get();
 
     $promise->then(
-        function ($c) use (&$resolved, &$wait, $loop) {
+        function ($c) use (&$resolved, &$wait) {
             $resolved = $c;
             $wait = false;
-            $loop->stop();
+            Loop::stop();
         },
-        function ($error) use (&$exception, &$rejected, &$wait, $loop) {
+        function ($error) use (&$exception, &$rejected, &$wait) {
             $exception = $error;
             $rejected = true;
             $wait = false;
-            $loop->stop();
+            Loop::stop();
         }
     );
 
@@ -81,7 +71,7 @@ function ($error) use (&$exception, &$rejected, &$wait, $loop) {
     $promise = null;
 
     while ($wait) {
-        $loop->run();
+        Loop::run();
     }
 
     if ($rejected) {

tests/AwaitTest.php

@@ -9,22 +9,12 @@
 
 class AwaitTest extends TestCase
 {
-    protected $loop;
-
-    /**
-     * @before
-     */
-    public function setUpLoop()
-    {
-        $this->loop = Loop::get();
-    }
-
     public function testAwaitOneRejected()
     {
         $promise = $this->createPromiseRejected(new \Exception('test'));
 
         $this->setExpectedException('Exception', 'test');
-        React\Async\await($promise, $this->loop);
+        React\Async\await($promise);
     }
 
     public function testAwaitOneRejectedWithFalseWillWrapInUnexpectedValueException()
@@ -36,7 +26,7 @@ public function testAwaitOneRejectedWithFalseWillWrapInUnexpectedValueException(
         $promise = Promise\reject(false);
 
         $this->setExpectedException('UnexpectedValueException', 'Promise rejected with unexpected value of type bool');
-        React\Async\await($promise, $this->loop);
+        React\Async\await($promise);
     }
 
     public function testAwaitOneRejectedWithNullWillWrapInUnexpectedValueException()
@@ -48,7 +38,7 @@ public function testAwaitOneRejectedWithNullWillWrapInUnexpectedValueException()
         $promise = Promise\reject(null);
 
         $this->setExpectedException('UnexpectedValueException', 'Promise rejected with unexpected value of type NULL');
-        React\Async\await($promise, $this->loop);
+        React\Async\await($promise);
     }
 
     /**
@@ -59,7 +49,7 @@ public function testAwaitOneRejectedWithPhp7ErrorWillWrapInUnexpectedValueExcept
         $promise = Promise\reject(new \Error('Test', 42));
 
         try {
-            React\Async\await($promise, $this->loop);
+            React\Async\await($promise);
             $this->fail();
         } catch (\UnexpectedValueException $e) {
             $this->assertEquals('Promise rejected with unexpected Error: Test', $e->getMessage());
@@ -74,7 +64,7 @@ public function testAwaitOneResolved()
     {
         $promise = $this->createPromiseResolved(2);
 
-        $this->assertEquals(2, React\Async\await($promise, $this->loop));
+        $this->assertEquals(2, React\Async\await($promise));
     }
 
     public function testAwaitReturnsFulfilledValueWithoutGivingLoop()
@@ -89,7 +79,7 @@ public function testAwaitOneInterrupted()
         $promise = $this->createPromiseResolved(2, 0.02);
         $this->createTimerInterrupt(0.01);
 
-        $this->assertEquals(2, React\Async\await($promise, $this->loop));
+        $this->assertEquals(2, React\Async\await($promise));
     }
 
     public function testAwaitOneResolvesShouldNotCreateAnyGarbageReferences()
@@ -101,7 +91,7 @@ public function testAwaitOneResolvesShouldNotCreateAnyGarbageReferences()
         gc_collect_cycles();
 
         $promise = Promise\resolve(1);
-        React\Async\await($promise, $this->loop);
+        React\Async\await($promise);
         unset($promise);
 
         $this->assertEquals(0, gc_collect_cycles());
@@ -117,7 +107,7 @@ public function testAwaitOneRejectedShouldNotCreateAnyGarbageReferences()
 
         $promise = Promise\reject(new \RuntimeException());
         try {
-            React\Async\await($promise, $this->loop);
+            React\Async\await($promise);
         } catch (\Exception $e) {
             // no-op
         }
@@ -140,7 +130,7 @@ public function testAwaitNullValueShouldNotCreateAnyGarbageReferences()
 
         $promise = Promise\reject(null);
         try {
-            React\Async\await($promise, $this->loop);
+            React\Async\await($promise);
         } catch (\Exception $e) {
             // no-op
         }
@@ -153,7 +143,7 @@ protected function createPromiseResolved($value = null, $delay = 0.01)
     {
         $deferred = new Deferred();
 
-        $this->loop->addTimer($delay, function () use ($deferred, $value) {
+        Loop::addTimer($delay, function () use ($deferred, $value) {
             $deferred->resolve($value);
         });
 
@@ -164,7 +154,7 @@ protected function createPromiseRejected($value = null, $delay = 0.01)
     {
         $deferred = new Deferred();
 
-        $this->loop->addTimer($delay, function () use ($deferred, $value) {
+        Loop::addTimer($delay, function () use ($deferred, $value) {
             $deferred->reject($value);
         });
 
@@ -173,9 +163,8 @@ protected function createPromiseRejected($value = null, $delay = 0.01)
 
     protected function createTimerInterrupt($delay = 0.01)
     {
-        $loop = $this->loop;
-        $loop->addTimer($delay, function () use ($loop) {
-            $loop->stop();
+        Loop::addTimer($delay, function () {
+            Loop::stop();
         });
     }