Server : Apache System : Linux server2.corals.io 4.18.0-348.2.1.el8_5.x86_64 #1 SMP Mon Nov 15 09:17:08 EST 2021 x86_64 User : corals ( 1002) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system Directory :  /home/corals/dceprojects.corals.io/node_modules/thunky/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

# thunky

Delay the evaluation of a paramless async function and cache the result (see [thunk](http://en.wikipedia.org/wiki/Thunk_%28functional_programming%29)).

	npm install thunky

## Example

Let's make a simple function that returns a random number 1 second after it is called for the first time

``` js
var thunky = require('thunky');

var test = thunky(function(callback) { // the inner function should only accept a callback
	console.log('waiting 1s and returning random number');
	setTimeout(function() {
		callback(Math.random());
	}, 1000);
});

test(function(num) {  // inner function is called the first time we call test
	console.log(num); // prints random number
});

test(function(num) {  // subsequent calls waits for the first call to finish and return the same value
	console.log(num); // prints the same random number as above
});
```

## Lazy evaluation

Thunky makes it easy to implement a lazy evaluation pattern.

``` js
var getDb = thunky(function(callback) {
	db.open(myConnectionString, callback);
});

var queryDb = function(query, callback) {
	getDb(function(err, db) {
		if (err) return callback(err);
		db.query(query, callback);
	});
};

queryDb('some query', function(err, result) { ... } );

queryDb('some other query', function(err, result) { ... } );
```

The first time `getDb` is called it will try do open a connection to the database.
Any subsequent calls will just wait for the first call to complete and then call your callback.

A nice property of this pattern is that it *easily* allows us to pass any error caused by `getDb` to the `queryDb` callback.

## Error → No caching

If the thunk callback is called with an `Error` object as the first argument it will not cache the result

``` js
var fails = thunky(function(callback) {
	console.log('returning an error');
	callback(new Error('bad stuff'));
});

fails(function(err) { // inner function is called
	console.log(err);
});

fails(function(err) { // inner function is called again as it returned an error before
	console.log(err);
});
```

## License

MIT