# Interface webdriver.promise.Thenable.`<T>`

code »

Thenable is a promise-like object with a `then` method which may be used to schedule callbacks on a promised value.

Show:Public Protected Private

## Instance Methods

code »cancel ( opt_reason )

Cancels the computation of this promise's value, rejecting the promise in the process. This method is a no-op if the promise has alreayd been resolved.

Parameters
opt_reason: `string=` The reason this promise is being cancelled.

code »isPending ( ) ⇒ `boolean`

Returns
Whether this promise's value is still being computed.

code »`<R>` then ( opt_callback, opt_errback ) ⇒ `!webdriver.promise.Promise.<R>`

Registers listeners for when this instance is resolved.

Parameters
opt_callback: `?(function(T): (R|webdriver.promise.Promise.<R>))=` The function to call if this promise is successfully resolved. The function should expect a single argument: the promise's resolved value. opt_errback: `?(function(*): (R|webdriver.promise.Promise.<R>))=` The function to call if this promise is rejected. The function should expect a single argument: the rejection reason.
Returns
A new promise which will be resolved with the result of the invoked callback.

code »`<R>` thenCatch ( errback ) ⇒ `!webdriver.promise.Promise.<R>`

Registers a listener for when this promise is rejected. This is synonymous with the `catch` clause in a synchronous API:

       // Synchronous API:
       try {
         doSynchronousWork();
       } catch (ex) {
         console.error(ex);
       }

       // Asynchronous promise API:
       doAsynchronousWork().thenCatch(function(ex) {
         console.error(ex);
       });

Parameters
errback: `function(*): (R|webdriver.promise.Promise.<R>)` The function to call if this promise is rejected. The function should expect a single argument: the rejection reason.
Returns
A new promise which will be resolved with the result of the invoked callback.

code »`<R>` thenFinally ( callback ) ⇒ `!webdriver.promise.Promise.<R>`

Registers a listener to invoke when this promise is resolved, regardless of whether the promise's value was successfully computed. This function is synonymous with the `finally` clause in a synchronous API:

       // Synchronous API:
       try {
         doSynchronousWork();
       } finally {
         cleanUp();
       }

       // Asynchronous promise API:
       doAsynchronousWork().thenFinally(cleanUp);

Note: similar to the `finally` clause, if the registered callback returns a rejected promise or throws an error, it will silently replace the rejection error (if any) from this promise:

       try {
         throw Error('one');
       } finally {
         throw Error('two');  // Hides Error: one
       }

       webdriver.promise.rejected(Error('one'))
           .thenFinally(function() {
             throw Error('two');  // Hides Error: one
           });

Parameters
callback: `function(): (R|webdriver.promise.Promise.<R>)` The function to call when this promise is resolved.
Returns
A promise that will be fulfilled with the callback result.

## Global Functions

code »webdriver.promise.Thenable.addImplementation ( ctor )

Adds a property to a class prototype to allow runtime checks of whether instances of that class implement the Thenable interface. This function will also ensure the prototype's `then` function is exported from compiled code.

Parameters
ctor: `function(new: webdriver.promise.Thenable, ?)` The constructor whose prototype to modify.

code »webdriver.promise.Thenable.isImplementation ( object ) ⇒ `boolean`

Checks if an object has been tagged for implementing the Thenable interface as defined by `webdriver.promise.Thenable.addImplementation`.

Parameters
object: `*` The object to test.
Returns
Whether the object is an implementation of the Thenable interface.

## Global Properties

code »webdriver.promise.Thenable.IMPLEMENTED_BY_PROP_ : `string`

Property used to flag constructor's as implementing the Thenable interface for runtime type checking.