0.0.1 • Published 3 years ago
nv-facutil-proposition-promise v0.0.1
nv-facutil-proposition-promise
- nv-facutil-proposition-promise
- bool operation of promise
install
- npm install nv-facutil-proposition-promise
usage
const {
not,tru_lize,fls_lize
} = require("nv-facutil-proposition-promise");not,tru_lize,fls_lize,state_lize
- not, tru_lize,fls_lize are state_lize level-0 operations
not(promise)
- if promise resolved, the returned-promise rejected
- if promise rejected, the returned-promise resolved
const rndp = require("nv-random-promise");
var p = rndp.one('ABC')
> p
Promise { <rejected> 'ABC' }
>
var np = not(p);
> np
Promise { 'ABC' }
> > var p = rndp.one('ABC')
> p
Promise { 'ABC' }
>
> var np = not(p);
> Uncaught 'ABC'
>
> np
Promise { <rejected> 'ABC' }
>tru_lize(promise)
- if promise settled, the returned-promise ALWAYS resolved
const rndp = require("nv-random-promise");
> var p = rndp.one('A')
> Uncaught 'A'
> p
Promise { <rejected> 'A' }
>
> var np = tru_lize(p)
> np
Promise { 'A' }
>fls_lize(promise)
- if promise settled, the returned-promise ALWAYS rejected
> var p = rndp.one('A')
> p
Promise { 'A' }
>
> var np = fls_lize(p)
> Uncaught 'A'
> np
Promise { <rejected> 'A' }
>state_lize(promise)
add a getter of promise-state
> var p = tmoutp(8000,'B') undefined > var np = state_lize(p) undefined > np.state_ 'pending' > p Promise { <pending> } > > p Promise { 'B' } > np.state_ 'resolved' >
level1
- at_least_some
- at_least_some_in_order
- must_some
- must_some_in_order
- at_most_some
- at_most_some_in_order
- some_between
- some_between_in_order
- at_least_certain
- at_least_certain_in_order
- must_certain
- must_certain_in_order
- at_most_certain
- at_most_certain_in_order
at_least_some(promise_array,count,in_settled_order=true)
- at least (count) be resolved
- if count > promise_array.length, it will a reject CountCanNotMatchError
- if success, resolve current-collected-results
- if fail, reject current-collected-errors
- if in_settled_order === true, the resolved/rejected will return-in-their-settled-order
- if in_settled_order === false, the resolved/rejected will return-in-their-original-order
var parr = rndp.some_with_values(['A','B','C','D'])
var np = at_least_some(parr,3)
> np
Promise { <rejected> [ 'B', 'D' ] }
>
> parr
[
Promise { 'A' },
Promise { <rejected> 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
>var parr = rndp.some_with_values(['A','B','C','D'])
var np = at_least_some(parr,3)
> np
Promise { [ 'A', 'B', 'D' ] }
>
> parr
[
Promise { 'A' },
Promise { 'B' },
Promise { <rejected> 'C' },
Promise { 'D' }
]
>in settled order
const tmoutp = require('timers/promises').setTimeout;
var parr = [
tmoutp(1000,'A'),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_least_some(parr,3)
> np
Promise { [ 'A', 'C', 'B' ] }in original order
var parr = [
tmoutp(1000,'A'),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_least_some(parr,3,false)
> np
Promise { [ 'A', 'B', 'C' ] }at_least_some_in_order(promise_array,count,in_settled_order=true)
- same as at_least_some, but the results must resolved in order
var parr = [
tmoutp(1000,'A'),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_least_some_in_order(parr,2)
> np
Promise { [ 'A', 'C' ] }
>
var parr = [
tmoutp(1000,'A'),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_least_some_in_order(parr,3)
> np
Promise {
<rejected> [OrderError: order-error] {
idx: 1, // B finished, its original index is 1
kind: 'ge',
lt: undefined,
le: undefined,
eq: undefined,
ge: 4, // B finished after C whose original index is 3,so the expected index >= 4
gt: undefined
}
}
>must_some(promise_array,count,in_settled_order=true)
- must (count) be resolved, others must be rejected
- if count > promise_array.length, it will a reject CountCanNotMatchError
- if success, resolve current-collected-results
- if fail, reject CountCanNotMatchError(when resolved exceeds count) OR current-collected-rejects
var parr = [
tmoutp(1000,'A'),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = must_some(parr,2)
> parr
[
Promise { 'A' },
Promise { 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
> np
Promise {
<rejected> [CountCanNotMatchError: count-can-not-match-error] {
kind: 'eq',
lt: undefined,
le: undefined,
eq: 2,
ge: undefined,
gt: undefined,
count: 3
}
}
> var parr = [
tmoutp(1000,'A'),
creat_setmout_reject('B',4000),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = must_some(parr,2,false)
> parr
[
Promise { 'A' },
Promise { <rejected> 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
> np
Promise { [ 'A', 'C' ] }
>must_some_in_order(promise_array,count,in_settled_order=true)
same as must_some, but the results must resolved in order
var parr = [ tmoutp(2000,'A'), // creat_setmout_reject('B',4000), tmoutp(1000,'C'), // C resolved before A creat_setmout_reject('D',3000), ]; var np = must_some_in_order(parr,2) > Uncaught [OrderError: order-error] { idx: 0, kind: 'ge', lt: undefined, le: undefined, eq: undefined, ge: 3, gt: undefined } > parr [ Promise { 'A' }, Promise { <rejected> 'B' }, Promise { 'C' }, Promise { <rejected> 'D' } ] >
var parr = [
tmoutp(1000,'A'), //A first
creat_setmout_reject('B',4000),
tmoutp(2000,'C'), //then C
creat_setmout_reject('D',3000),
];
var np = must_some_in_order(parr,2)
> parr
[
Promise { 'A' },
Promise { <rejected> 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
> np
Promise { [ 'A', 'C' ] }
> at_most_some(promise_array,count,in_settled_order=true)
- at most (count) be resolved
- if count > promise_array.length, it will a reject CountCanNotMatchError
- if success, resolve current-collected-results
- if fail,CountCanNotMatchError(when resolved exceeds count)
var parr = [
tmoutp(1000,'A'),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_most_some(parr,2)
> np
Promise {
<rejected> [CountCanNotMatchError: count-can-not-match-error] {
kind: 'eq',
lt: undefined,
le: undefined,
eq: 2,
ge: undefined,
gt: undefined,
count: 3
}
} var parr = [
tmoutp(1000,'A'),
creat_setmout_reject('B',4000),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_most_some(parr,2)
> np
Promise { [ 'A', 'C' ] }
>at_most_some_in_order(promise_array,count,in_settled_order=true)
- same as at_most_some, but the results must resolved in order
var parr = [
tmoutp(1000,'A'),
creat_setmout_reject('B',4000),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_most_some_in_order(parr,2)
> np
Promise { [ 'A', 'C' ] }
> var parr = [
tmoutp(2000,'A'), //A after C will fail
creat_setmout_reject('B',4000),
tmoutp(1000,'C'),
creat_setmout_reject('D',3000),
];
var np = at_most_some_in_order(parr,2)
> np
Promise {
<rejected> [OrderError: order-error] {
idx: 0,
kind: 'ge',
lt: undefined,
le: undefined,
eq: undefined,
ge: 3,
gt: undefined
}
}
> parr
[
Promise { 'A' },
Promise { <rejected> 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
>some_between(promise_array,count_ge,count_lt,in_settled_order=true)
the reolved count >= count_ge AND < count_lt
var parr = [ creat_setmout_reject('A',1000), tmoutp(4000,'B'), tmoutp(2000,'C'), creat_setmout_reject('D',3000), ];
var np = some_between(parr,2,4)
> np
Promise { [ 'B', 'C' ] }
>
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = some_between(parr,1,2)
> np
Promise {
<rejected> [CountCanNotMatchError: count-can-not-match-error] {
kind: 'lt',
lt: 2,
le: undefined,
eq: undefined,
ge: undefined,
gt: undefined,
count: 2
}
}
>
> parr
[
Promise { <rejected> 'A' },
Promise { 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
>some_between_in_order(promise_array,count_ge,count_lt,in_settled_order=true)
- same as some_between, but must be settled in order
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'), //B after C will fail
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
];
var np = some_between_in_order(parr,2,4)
> parr
[
Promise { <rejected> 'A' },
Promise { 'B' },
Promise { 'C' },
Promise { <rejected> 'D' }
]
> np
Promise {
<rejected> [OrderError: order-error] {
idx: 1,
kind: 'ge',
lt: undefined,
le: undefined,
eq: undefined,
ge: 4,
gt: undefined
}
}
> var parr = [
creat_setmout_reject('A',1000),
tmoutp(2000,'B'),
tmoutp(3000,'C'),
creat_setmout_reject('D',4000),
];
var np = some_between_in_order(parr,2,3)
Promise { [ 'B', 'C' ] } var parr = [
creat_setmout_reject('A',1000),
tmoutp(2000,'B'),
tmoutp(3000,'C'),
creat_setmout_reject('D',4000),
];
var np = some_between_in_order(parr,1,2)
> Uncaught CountCanNotMatchError: count-can-not-match-error
at _between_final (/opt/JS/NV5_/nv-facutil_/pkgs/nv-facutil-proposition-promise/l1.js:342:17) {
kind: 'lt',
lt: 2,
le: undefined,
eq: undefined,
ge: undefined,
gt: undefined,
count: 2
}at_leaset_certain(promise_array,whiches,in_settled_order=true)
- promise whose indexes in whiches must be resolved
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
tmoutp(1000,'E'),
];
var np = at_least_certain(parr,[1,4]) //'B' and 'E' must be resolved
> np
Promise { [ 'E', 'B' ] }
> var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(2000,'C'),
creat_setmout_reject('D',3000),
tmoutp(1000,'E'),
];
var np = at_least_certain(parr,[0,4]) //'A' and 'E' must be resolved
> np
Promise { <rejected> [ 'A' ] }
>at_leaset_certain_in_order(promise_array,whiches,in_settled_order=true)
- same as at_leaset_certain ,but must be settled in order
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
creat_setmout_reject('D',6000),
tmoutp(1000,'E'),
];
var np = at_least_certain_in_order(parr,[1,4]) //'B' and 'E' must be resolved in order
> np
Promise {
<rejected> [OrderError: order-error] {
idx: 2,
kind: 'ge',
lt: undefined,
le: undefined,
eq: undefined,
ge: 5,
gt: undefined
}
} var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
creat_setmout_reject('D',6000),
tmoutp(7000,'E'),
];
var np = at_least_certain_in_order(parr,[1,4]) //'B' and 'E' must be resolved in order
> np
Promise { [ 'B', 'E' ] }must_certain(promise_array,whiches,in_settled_order=true)
- whiches be resolved , others be rejected
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
creat_setmout_reject('D',6000),
tmoutp(1000,'E'),
];
var np = must_certain(parr,[1,4]) // only 'B' and 'E' must be resolved
Promise {
<rejected> [CountCanNotMatchError: count-can-not-match-error] {
kind: 'eq',
lt: undefined,
le: undefined,
eq: 2,
ge: undefined,
gt: undefined,
count: 3
}
} var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
creat_setmout_reject('C',6000),
creat_setmout_reject('D',6000),
tmoutp(1000,'E'),
];
var np = must_certain(parr,[1,4]) //only 'B' and 'E' must be resolved
> np
Promise { [ 'B', 'E' ] }
>must_certain_in_order(promise_array,whiches,in_settled_order=true)
- same as must_certain , but must be settled in order
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
creat_setmout_reject('D',6000),
tmoutp(1000,'E'),
];
var np = must_certain_in_order(parr,[1,2,4]) // only 'B','C','E' resolved-in-order
> Uncaught [OrderError: order-error] {
idx: 1,
kind: 'ge',
lt: undefined,
le: undefined,
eq: undefined,
ge: 5,
gt: undefined
} var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
creat_setmout_reject('D',6000),
tmoutp(6000,'E'),
];
var np = must_certain_in_order(parr,[1,2,4]) // only 'B','C','E' resolved-in-order
> np
Promise { [ 'B', 'C', 'E' ] }
> var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
tmoutp(5000,'D'),
tmoutp(6000,'E'),
];
var np = must_certain_in_order(parr,[1,2,4]) // only 'B','C','E' resolved-in-order
> Uncaught [IndexCanNotMatchError: index-can-not-match-error] {
kind: 'in',
index_range: [ 0, 5 ],
required_indexes: [ 1, 2, 4 ],
invalid_index: 3
}
> parr
[
Promise { <rejected> 'A' },
Promise { 'B' },
Promise { 'C' },
Promise { 'D' }, ///------------------>
Promise { 'E' }
] at_most_certain(promise_array,whiches,in_settled_order=true)
var parr = [
creat_setmout_reject('A',1000),
tmoutp(4000,'B'),
tmoutp(5000,'C'),
creat_setmout_reject('D',6000),
tmoutp(1000,'E'),
];
var np = at_most_certain(parr,[1,4]) // only 'B' or 'E' can be resolved
> np
Promise {
<rejected> [CountCanNotMatchError: count-can-not-match-error] {
kind: 'eq',
lt: undefined,
le: undefined,
eq: 2,
ge: undefined,
gt: undefined,
count: 3
}
}
> var parr = [
creat_setmout_reject('A',1000),
creat_setmout_reject('B',3000),
creat_setmout_reject('C',6000),
creat_setmout_reject('D',6000),
tmoutp(1000,'E'),
];
var np = at_most_certain(parr,[1,4]) // only 'B' or 'E' can be resolved
> np
Promise { [ 'E' ] }
>at_most_certain_in_order(promise_array,whiches,in_settled_order=true)
var parr = [
creat_setmout_reject('A',1000),
tmoutp(2000,'B'),
creat_setmout_reject('C',3000),
tmoutp(5000,'D'),
tmoutp(1000,'E'),
];
var np = at_most_certain_in_order(parr,[1,2,4]) // only 'B' or 'D' or 'E' can be settled in order
> np
Promise {
<rejected> [OrderError: order-error] {
idx: 1,
kind: 'ge',
lt: undefined,
le: undefined,
eq: undefined,
ge: 5,
gt: undefined
}
} var parr = [
creat_setmout_reject('A',1000),
tmoutp(2000,'B'),
tmoutp(4000,'C'),
creat_setmout_reject('D',5000),
tmoutp(6000,'E'),
];
var np = at_most_certain_in_order(parr,[1,2,4])
> Promise { [ 'B', 'C', 'E' ] }level2
- and,or are level-2 operations
and(promise_array,in_settled_order=true)
- same as at_least_some(promise_array,promise_array.length,in_settled_order)
or(promise_array,in_settled_order=true)
- same as at_least_some(promise_array,1,in_settled_order)
and_in_order(promise_array,in_settled_order=true)
- same as at_least_some_in_order(promise_array,promise_array.length,in_settled_order)
API
LICENSE
- ISC
0.0.1
3 years ago