lib/Promise.php
private function invokeCallback(Promise $subPromise, callable $callBack = null)
    {
        // We use 'nextTick' to ensure that the event handlers are always
        // triggered outside of the calling stack in which they were originally
        // passed to 'then'.
        //
        // This makes the order of execution more predictable.
        Loop\nextTick(function () use ($callBack, $subPromise) {
            if (is_callable($callBack)) {
                try {
                    $result = $callBack($this->value);
                    if ($result instanceof self) {
                        // If the callback (onRejected or onFulfilled)
                        // returned a promise, we only fulfill or reject the
                        // chained promise once that promise has also been
                        // resolved.
                        $result->then([$subPromise, 'fulfill'], [$subPromise, 'reject']);
                    } else {
                        // If the callback returned any other value, we
                        // immediately fulfill the chained promise.
                        $subPromise->fulfill($result);
                    }
                } catch (Throwable $e) {
                    // If the event handler threw an exception, we need to make sure that
                    // the chained promise is rejected as well.
                    $subPromise->reject($e);
                }
            } else {
                if (self::FULFILLED === $this->state) {
                    $subPromise->fulfill($this->value);
                } else {
                    $subPromise->reject($this->value);
                }
            }
        });
    }
private function invokeCallback(Promise $subPromise, callable $callBack = null)
    {
        // We use 'nextTick' to ensure that the event handlers are always
        // triggered outside of the calling stack in which they were originally
        // passed to 'then'.
        //
        // This makes the order of execution more predictable.
        Loop\nextTick(function () use ($callBack, $subPromise) {
            if (is_callable($callBack)) {
                try {
                    $result = $callBack($this->value);
                    if ($result instanceof self) {
                        // If the callback (onRejected or onFulfilled)
                        // returned a promise, we only fulfill or reject the
                        // chained promise once that promise has also been
                        // resolved.
                        $result->then([$subPromise, 'fulfill'], [$subPromise, 'reject']);
                    } else {
                        // If the callback returned any other value, we
                        // immediately fulfill the chained promise.
                        $subPromise->fulfill($result);
                    }
                } catch (Throwable $e) {
                    // If the event handler threw an exception, we need to make sure that
                    // the chained promise is rejected as well.
                    $subPromise->reject($e);
                }
            } else {
                if (self::FULFILLED === $this->state) {
                    $subPromise->fulfill($this->value);
                } else {
                    $subPromise->reject($this->value);
                }
            }
        });
    }
private function invokeCallback ( Promise $ subPromise , callable $ callBack = null ) { // We use 'nextTick' to ensure that the event handlers are always // triggered outside of the calling stack in which they were originally // passed to 'then'. // // This makes the order of execution more predictable. Loop \ nextTick ( function ( ) use ( $ callBack , $ subPromise ) { if ( is_callable ( $ callBack ) ) { try { $ result = $ callBack ( $ this -> value ) ; if ( $ result instanceof self ) { // If the callback (onRejected or onFulfilled) // returned a promise, we only fulfill or reject the // chained promise once that promise has also been // resolved. $ result -> then ( [ $ subPromise , 'fulfill' ] , [ $ subPromise , 'reject' ] ) ; } else { // If the callback returned any other value, we // immediately fulfill the chained promise. $ subPromise -> fulfill ( $ result ) ; } } catch ( Throwable $ e ) { // If the event handler threw an exception, we need to make sure that // the chained promise is rejected as well. $ subPromise -> reject ( $ e ) ; } } else { if ( self :: FULFILLED === $ this -> state ) { $ subPromise -> fulfill ( $ this -> value ) ; } else { $ subPromise -> reject ( $ this -> value ) ; } } } ) ; }
This method is used to call either an onFulfilled or onRejected callback.

This method makes sure that the result of these callbacks are handled
correctly, and any chained promises are also correctly fulfilled or
rejected.

@param Promise  $subPromise
@param callable $callBack
This method is used to call either an onFulfilled or onRejected callback .