Package Exports

righto

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (righto) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Righto

Wana do some async stuff? Righto..

What

make caching, dependency resolving tasks

righto takes a task to run, and arguments to pass to the task. If you pass a righto'd task as an argument, it will be resolved before running the dependant task.

righto(task, [argument or righto task])

righto'd tasks are resolved once and the result is cached. If a task is in flight when it's results are asked for, the results will be passed when the task resolves.

example:

async dependencies passed to bar:

// Just your average callback-passing-style function.
function foo(callback){

    setTimeout(function(){

        callback(null, 'world');

    }, 1000);

}

// A righto callback-passing-style function
var getFoo = righto(foo);

// Another normal callback-passing-style function.
function bar(a, callback){
    callback(null, 'hello ' + a);
}

// Another righto
var getBar = righto(bar, getFoo);

getBar(function(error, result){

    // ...about 1 second later...
    result -> 'hello world';

});

Errors

Errors bubble up through tasks, so if a dependancy errors, the task errors.

// Task that errors
function foo(callback){

    setTimeout(function(){

        callback(new Error('IT BORKED!'));

    }, 1000);

}

var getFoo = righto(foo);

function bar(a, callback){
    callback(null, 'hello ' + a);
}

var getBar = righto(bar, getFoo);

getBar(function(error, result){

    // ...about 1 second later...
    error -> IT BORKED!;

});

Multiple results

By default, dependant tasks are passed only the first result of a dependency righto. eg:

function foo(callback){
    setTimeout(function(){

        callback(null, 'first', 'second', 'third');

    }, 1000);
}

var getFoo = righto(foo);

function bar(a, callback){
    callback(null, a);
}

var getBar = righto(bar, getFoo);

getBar(function(error, result){
    // ...1 second later...
    result -> 'first';
});

But you can pick and choose what results are used from a dependancy like so:

function foo(callback){
    setTimeout(function(){

        callback(null, 'first', 'second', 'third');

    }, 1000);
}

var getFoo = righto(foo);

function bar(a, b callback){
    callback(null, [a, b].join(' '));
}

var getBar = righto(bar, [getFoo, 0, 2]); // Take result 0, and result 2, from getFoo

getBar(function(error, result){
    // ...1 second later...
    result -> 'first third';
});

Subkeys

You can create a new righto that resolves the key/runs a function on a result like so:

var user = righto(getUser);

var userName = user.get('name');
// OR: Use a function
var userName = user.get(user => user.name);

userName(function(error, name){
    // error or userName.
});

And keys can be righto's as well:

var user = righto(getUser);
var userKey = righto(getKey);

var userName = user.get(userKey);

userName(function(error, something){
    // error or something.
});

Possible rightos: righto.from(anything)

Any value can be turned into a righto using righto.from();

var num = righto.from(1); // -> righto:number;
var string = righto.from('hello'); // -> righto:string;
var nothing = righto.from(null); // -> righto:null;
var anyValue = righto.from(anything); // -> righto:anything;

var self = righto.from(someRighto); // -> someRighto;

Group

Occasionally you might want to mate a number of tasks into one task.

For this, you can use righto.mate.

function getStuff(callback){

    // eventually...
    callback(null, 3);
}

var stuff = righto(getStuff);

function getOtherStuff(callback){

    // eventually...
    callback(null, 7);
}

var otherStuff = righto(getOtherStuff);

var stuffAndOtherStuff = righto.mate(stuff, otherStuff);

stuffAndOtherStuff(function(error, stuff, otherStuff){
    error -> null
    stuff -> 3
    otherStuff -> 7
});