Promise it's partial

Make your code reasonable
Jim Argeropoulos
@ExploreMqt

CALLBACK
fs.readFile('/etc/passwd',
function(err, data){
if (err) throw err;
console.log(data);
});

RACE STANDINGS
Read the 6 hour solo records
Read the 12 hour solo records
Read the 6 hour team records
Read the 12 hour team records
Merge the results

RACE STANDINGS
model.Team.find({group:'solo', duration:'6'}, function(err,s6){
model.Team.find({group:{$ne:'solo'}, duration:'6'}, function(err,t6){
res.render('index', {
title: '12 Hours of Potluck',
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

CALLBACK HELL
model.Team.find({group:'solo', duration:'6'}, ['name'], function(err,s6){
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

QUERY ONE
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

QUERY TWO
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

QUERY THREE
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

QUERY FOUR
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

PROMISES
Q RSVP
ES6/2015
kew
when
vow
thenFail
bluebird

PROMISE
Pending
Resolved
Rejected

CONSUMER
producePromise()
.then(console.log)
.catch(console.error)

PRODUCER
function divide(numerator, denominator){
return new Promise((resolve, reject)=>{
if (denominator !== 0)
resolve(numerator / denominator)
reject('divide by zero')
})
}

IN ACTION
})
}
divide(15, 3)
.then(console.log)

IN ACTION
})
}
divide(15, 3)
.then(console.log) // 5

IN ACTION
})
}
divide(10, 0)
.then(console.log)

IN ACTION
})
}
divide(10, 0)
.then(console.log)
.catch(console.error) // ‘divide by zero’

ALREADY KNOWN
return denominator ?
Promise.resolve(numerator / denominator) :
Promise.reject ('divide by zero')
}
divide(15, 3)
divide(10, 0)
.then(console.log)
.catch(console.error) // ‘divide by zero’

CALLBACK VERSION
model.Team.find({group:'solo', duration:'6'}, ['name'], function(err,s6){
solo6: s6,
solo12: s12,
team6: t6,
team12: t12});
});
});
});
});

WRAPPER
function find(team, query){
return new Promise(resolve, reject)=>{
team.find( query,
(err, docs)=>{
if(err)
reject(err)
resolve(docs)
})
})
}

ALL
var tasks = [task1, task2, task3, …]
Promise.all(tasks)
.then(results => {
//… all resolved: process results
}
.catch(err => {
// one rejected: handle err
}

PROMISE.ALL
Promise.all([
find(model.team, {group:'solo', duration:'6'}),
find(model.team, {group:'solo', duration:'12'}),
find(model.team, {group:{$ne:'solo'}, duration:'6'}),
find(model.team, {group:{$ne:'solo'}, duration:'12'}
])
.then(results => {
solo6: results[0],
solo12: results[1],
team6: results[2],
team12: results[3]});
});
})

PIPELINE
$ls -l | grep "Aug" | sort +4n | more
-rw-rw-rw- 1 john doc 11008 Aug 6 14:10 ch02
-rw-rw-rw- 1 john doc 8515 Aug 6 15:30 ch07
-rw-rw-r-- 1 john doc 2488 Aug 15 10:51 intro
-rw-rw-r-- 1 carol doc 1605 Aug 23 07:35 macros
$

CHAINING
Promise.resolve(10)
.then(n => 2 * n) // <= NOT a promise

CHAINING
function rejectN(n){
Promise.reject(’just because’)
}
Promise.resolve(10)
.then(n => 2 * n)
.then(rejectN)
.then(n => 3 * n)
.then(console.log)

MORE DATA?
Promise.resolve(10)
.then(divide)
.then(console.log)
What if you need a second parameter?

ADD
function add(x, y){
return x + y
}

OVERLOAD
function add(x, y){
return x + y
}
var add5(y){
return add(5, y)
}
console.log(add5(1)) // 6

OVERLOAD
function add(x, y){
return x + y
}
var add5(y){
return add(5, y)
}
var add6(y){
return add(6, y)
}

BIND
function add(x, y){
return x + y
}
var add5 = add.bind(undefined, 5)

PARTIAL
var _ = require(‘lodash’)
//could also use ramda
function add(x, y){
return x + y
}
var add5 = _.partial(add, 5)

PARTIAL RIGHT
var _ = require(‘lodash’)
function add(x, y){
console.log(‘x’, x) // x 1
console.log(‘y’, y) // y 5
return x + y
}
var add5 = _.partialRight(add, 5)

var _ = require(‘lodash')
function readPeopleFromFile(){
Promise.resolve([
{name: 'Risto', age: 6 },
{name: 'Niilo', age: 8 },
{name: 'Edla', age: 12 }])
}
}
readPeopleFromFile()
//filter the people younger than 10,
//_.filter(collection, [predicate=_.identity], [thisArg])
//order by name
//_.sortBy(collection, [iteratee=_.identity], [thisArg])
PARTIAL IN ACTION

PARTIAL IN ACTION
var _ = require('lodash')
Promise.resolve([
}
}
.then(_.partialRight(_.filter, p => p.age < 10))
.then(_.partialRight(_.sortBy, 'name'))
.then(console.log)
//[{name: 'Niilo', age: 8 },
// {name: 'Risto', age: 6 }]

SHORT HAND
var mock{
readPeopleFromFile: () => Promise.resolve([]),
render: () => {}
}
inject = _.partial(_.extend, {}, mock)
it('should not use the file system’,() => {
readKids(inject({
readPeopleFromFile: () => {
Promise.resolve([
}
}
}))
.then(result => {
result[0].name.should.equal('Niilo')
})
})

SEPTEMBER 8
Node 4.0 Now with Arrow Functions!

Arrow Functions > partialRight

Promise.resolve([
}
}
.then(_.partialRight(_.filter, p => p.age < 10))
.then(_.partialRight(_.sortBy, 'name'))
.then(console.log)
PARTIAL IN ACTION

CLOSURE
Promise.resolve([
.then(people => _.filter(people, p => p.age < 10))
.then(people => _.sortBy(people, 'name'))
.then(console.log)

BEST PRACTICES
Promise.resolve(10)
.then(n => 2 * n)
.then(largeBusinessRule)
.then(console.log)

BEST PRACTICES
validateParams(req) // <= not blocking
.then(blockingTask)
.then(parseResults)
.then(pageResults)

SUMMARY
What is a Promise
Consume a promise
Produce a promise
Manage multiple blocking tasks with promises
Chain small tasks
Partial application
Closure

CONTACT
Jim Argeropoulos
tenholeharp@gmail.com
@ExploreMqt

ASYNC SOLUTION
async.parallel([
cb => { model.Team.find({group:'solo', duration:'6'}, cb)},
cb => { model.Team.find({group:'solo', duration:'12'}, cb)},
cb => { model.Team.find({group:{$ne:'solo'}, duration:'6'}, cb)},
cb => { model.Team.find({group:{$ne:'solo'}, duration:'12'}, cb)},
],
results => {
solo6: results[0],
solo12: results[1],
team6: results[2],
team12: results[3]});
}
)

Promise it's partial

More Related Content

What's hot

Similar to Promise it's partial

Recently uploaded

Promise it's partial

Editor's Notes