logical-promise
logical-promise uses template literals to perform logical operators on Promises.
logical-promise will change the way you write Promises.
Supported operators:
- Logical AND:
&& - Logical OR:
|| - Logical NOT:
! - Parenthese:
(and) - Conditional(ternary) operators:
?and:
Install
$ npm install logical-promiseExamples
import logical, {
FULLFILLED,
FULLFILLED_AND_TRUE
} from 'logical-promise'
const resolve = n => Promise.resolve(n)
const reject = n => Promise.reject(n)
1. By default, if rejected, then go into logical OR
logical `${reject(1)} || ${resolve(0)}`
// Promise.resolve(0)2. Specify condition method. Equivalent to example 1.
logical(FULLFILLED) `${reject(1)} || ${resolve(0)}`
// Promise.resolve(0)3. Change the behavior using condition method
logical `
${reject(1)}
|| ${resolve(0)}
|| ${resolve(2)}
`
// Promise.resolve(0)
logical(FULLFILLED_AND_TRUE) `
${reject(1)}
|| ${resolve(0)}
|| ${reject(2)}
`
// Promise.reject(2)4. Uses factory functions that return promises.
import {
factory
} from 'logical-promise'
factory `
${() => Promise.reject(1)}
&& ${() => Promise.resolve(0)}
`
// Promise.reject(1)By using factory, we could prevent unnecessary Promise branch from executing. For example:
import delay from 'delay'
let obj
const p1 = () => delay(10).then(() => {
obj = {a: 1}
})
const p2 = () => obj.alogical `${p1()} && ${p2()}` // Booooooooooooom !!!If use factory:
obj = null
factory `${p1} && ${p2}` // Promise.resolve(1)
5. You could also use condition method with factory
factory(FULLFILLED_AND_TRUE) `
${() => reject(1)}
|| ${() => resolve(0)}
|| ${() => resolve(2)}
`
// Promise.resolve(2)
6. Ternary operators (a ? b : c) are also supported
const f = n => resolve(n)
factory(FULLFILLED_AND_TRUE) `
${f(0)}
? ${f(1)}
// We can also write comments here.
// Even nested ternary operators are supported.
: ${f(0)}
? ${f(2)}
: ${f(3)} && ${f(4)}
`
// Promise.resolve(4)
7. Promises are not always required, but it always returns a Promise
logical(FULLFILLED_AND_TRUE) `${0} || ${resolve(1)}`
// Promise.resolve(1)
factory(FULLFILLED_AND_TRUE) `${() => 0} || ${() => 1}`
// Promise.resolve(1)Usage
logical(operators, ...promises)
logical `template`
logical(condition) `template`
factory `template`
factory(condition) `template`-
condition
function(promise: Promise): BooleanThe method to check whether a expression should be treated astrue.
Returns Promise
Built-in condition methods.
FULLFILLED
const FULLFILLED = promise => promise.then(
() => true,
() => false
)
FULLFILLED_AND_TRUE
const FULLFILLED_AND_TRUE = promise => promise.then(
result => !!result,
() => false
)How does it work
If you have figured it out how template literals works, then it is easy to find out that the example 1 is equivalent to:
// Spaces will be trimmed
logical(['', ' || ', ''], reject(1), resolve(0))Template literals do a great job to tokenize the source code for us
License
MIT
