## tryto ⇒ module:tryto~Tryto The default export for the library is a factory function which wraps the Tryto constructor. **Returns**: module:tryto~Tryto - A 'Tryto' instance which can be configured to run the supplied function until it succeeds (or any configured limits are hit). | Param | Type | Description | | --- | --- | --- | | fn | function | The function which is to be (re)tried. | * [tryto](#module_tryto) ⇒ module:tryto~Tryto * [.Tryto](#module_tryto.Tryto) * [new Tryto(fn)](#new_module_tryto.Tryto_new) * [.for(times)](#module_tryto.Tryto+for) ⇒ module:tryto~Tryto * [.every(delay)](#module_tryto.Tryto+every) ⇒ module:tryto~Tryto * [.using(strategy)](#module_tryto.Tryto+using) ⇒ module:tryto~Tryto * [.config(config)](#module_tryto.Tryto+config) ⇒ module:tryto~Tryto * [.now()](#module_tryto.Tryto+now) ⇒ Promise * [.in(delay)](#module_tryto.Tryto+in) ⇒ Promise * [.nobackoff](#module_tryto.nobackoff) : function * [.linear](#module_tryto.linear) : function * [.exponential](#module_tryto.exponential) : function * [.fibonacci](#module_tryto.fibonacci) : function ### tryto.Tryto The main 'tryto' class, which is created with a function to (re)try, it can then be configured via a series of chainable method calls, and finally started - which returns a promise. **Kind**: static class of [tryto](#module_tryto) * [.Tryto](#module_tryto.Tryto) * [new Tryto(fn)](#new_module_tryto.Tryto_new) * [.for(times)](#module_tryto.Tryto+for) ⇒ module:tryto~Tryto * [.every(delay)](#module_tryto.Tryto+every) ⇒ module:tryto~Tryto * [.using(strategy)](#module_tryto.Tryto+using) ⇒ module:tryto~Tryto * [.config(config)](#module_tryto.Tryto+config) ⇒ module:tryto~Tryto * [.now()](#module_tryto.Tryto+now) ⇒ Promise * [.in(delay)](#module_tryto.Tryto+in) ⇒ Promise #### new Tryto(fn) Makes a new Tryto instance. | Param | Type | Description | | --- | --- | --- | | fn | function | The function this Tryto will be trying to run. | #### tryto.for(times) ⇒ module:tryto~Tryto Specify how many times the function should be tried before rejecting. **Kind**: instance method of [Tryto](#module_tryto.Tryto) **Returns**: module:tryto~Tryto - This instance, for chaining. | Param | Type | Description | | --- | --- | --- | | times | Number | The number of times to retry the function associated with this Tryto before giving up. | #### tryto.every(delay) ⇒ module:tryto~Tryto Specify how frequently the function should be tried (initially, at least). **Kind**: instance method of [Tryto](#module_tryto.Tryto) **Returns**: module:tryto~Tryto - This instance, for chaining. | Param | Type | Description | | --- | --- | --- | | delay | Number | The initial delay (in milliseconds) at which to retry the function, should it fail. | #### tryto.using(strategy) ⇒ module:tryto~Tryto Choose the strategy which will be used for calculating the next delay (backoff). **Kind**: instance method of [Tryto](#module_tryto.Tryto) **Returns**: module:tryto~Tryto - This instance, for chaining. | Param | Type | Description | | --- | --- | --- | | strategy | function | Either a 'nextable' - a function which can be repeatedly called to get the next delay - or a 'nextable' factory, which can be called with a config object and returns a 'nextable' as a result. | #### tryto.config(config) ⇒ module:tryto~Tryto Set any configuration for the strategy which is active when the retries are started. **Kind**: instance method of [Tryto](#module_tryto.Tryto) **Returns**: module:tryto~Tryto - This instance, for chaining. | Param | Type | Description | | --- | --- | --- | | config | Object | A configuration object which will be passed to the 'nextable' factory function of the active strategy when 'in' or 'now' is called. | #### tryto.now() ⇒ Promise Start attempting to run the function immediately (well, on the next tick...). **Kind**: instance method of [Tryto](#module_tryto.Tryto) **Returns**: Promise - A promise which resolves with the result of the function, if it succeeds, or rejects should the function fail to execute successfully before the configured limits are hit. #### tryto.in(delay) ⇒ Promise Start attempting to run the function after the scheduled amount of time. **Kind**: instance method of [Tryto](#module_tryto.Tryto) **Returns**: Promise - A promise which resolves with the result of the function, if it succeeds, or rejects should the function fail to execute successfully before the configured limits are reached. | Param | Type | Description | | --- | --- | --- | | delay | Number | The delay (in milliseconds) after which to start trying the function. | ### tryto.nobackoff : function A strategy which never increases the retry delay. **Kind**: static property of [tryto](#module_tryto) ### tryto.linear : function A strategy which increases the retry delay linearly. **Kind**: static property of [tryto](#module_tryto) ### tryto.exponential : function A strategy which increases the retry delay exponentially. **Kind**: static property of [tryto](#module_tryto) ### tryto.fibonacci : function A strategy which increases the retry delay based on the fibonacci sequence. **Kind**: static property of [tryto](#module_tryto)