VimUnDo i5rF2Ҋ^uf1. ( PZ [ _ P~ 5_ v P~
function map(source, f) { /** E Returns transformed version of given `source` where each item of it is mapped using `f`. / var data = [{ name: "foo" }, { name: "bar" }] > var names = map(data, function(value) { return value.name }) ( print(names) => **/ ? return transform(source, function(next, value, accumulated) { & return next(f(value), accumulated) }) }5_ v P~ 5_ v P~ 5_ v P~ 5_ v P~! 5_ v P~" 5_ v P~% module.exports = map5_
v P~* &var transform = require("./transform")5_
& v P~- (var transformer = require("./transform")5_
* v P~4 5_
* v P~5 *var transformer = require("./transformer")5_
& * v P~8 (var transform = require("./transformer")5_
# * v P~= 5_ * v P~B var accumulated = require()5_ * v P~B var accumulated = require("")5_ ) v P~F *var accumulated = require("./accumulated")5_ ) v P~G 5_ ) v P~I 5_ ) v P~k * 5_
) v P~m K Returns stream containing first `n` elements of given `source`, on which5_
) v P~p J Returns stream containing first `n` elements of given `source`, on which5_
) v P~v L Returns sequence containing first `n` elements of given `source`, on which5_
( ) v P~y D Returns sequence of first `n` elements of given `source`, on which5_
8 ) v P~ A Returns sequence of first `n` items of given `source`, on which5_
9 ) v P~ A Returns sequence of first `n` items of given `source`. on which5_ ) v P~
on which5_ ) v P~
given lambda returns `true`.5_ ) v P~
O Composes version of given `source` containing only element up until `f(item)`5_ ) v P~
was true.5_
) ) v P~ 8 Returns sequence of first `n` items of given `source`.5_ !
< ) v P~ < Returns sequence of first `n` items of the given `source`.5_ " !
I ) v P~ Q Returns sequence of first `n` items of the given `source`. If `source` contains5_ ! # "
) v P~
contains5_ " $ # $ ) v P~
$ contains less items than `n` then 5_ # % $ ) v P~ 5_ $ & % ) v P~ ! ' var numbers = list(10, 23, 2, 7, 17)5_ % ' & $ ) v P~ ! $ var numbers = [ 10, 23, 2, 7, 17)5_ & ( ' ) v P~ ! #var digits = take(function(value) {5_ ' ) ( ) v P~ ! % var digits = take(function(value) {5_ ( * ) ) v P~ " ! 5_ ) + * ) v P~ return value >= 105_ * , + ) v P~ }, numbers)5_ + - , ) v P~ & var digits = take(function(value) {5_ , . - ) v P~ % var numbers = [ 10, 23, 2, 7, 17 ]5_ - / . ) v P~ % var digits = take(function(value) {5_ . 0 / 8 v P 5_ / 1 0 8 v P 8 print(take([ 1, 2, 3, 4, 5 ], 2)) // => 5_ 0 2 1 8 v P 2 print(take([ 1, 2, 3 ], 2)) // => 5_ 1 3 2 / 8 v P
2 print(take([ 1, 2, 3 ], 5)) // => 5_ 2 6 3 8 v P 5_ 3 7 4 6 $ 4 v P| 8 print(take([ 1, 2, 3, 4, 5 ], 2)) // => 5_ 6 8 7 4 v P~ 4 print(take([ 1, 2, 3 ], 5)) // => 5_ 7 9 8 4 v P 5_ 8 : 9 4 v P
## Example5_ 9 ; : 4 v P 5_ : < ; PK M/*jshint asi: true undef: true es5: true node: true browser: true devel: true5_ ; = < PK 9 forin: true latedef: false globalstrict: true */5_ < > = PK 5_ = ? > PK
'use strict';5_ > @ ? PK
"use strict';5_ ? A @ Ph *var accumulated = require("./accumulated")5_ @ B A $ Pl &var reduced = require("./accumulated")5_ A C B + Pp E return count === 0 ? next(accumulated(), next(value, result)) :5_ B D C ) Ps 4 next(accumulated(), result)5_ C E D P 5_ D F E P return reducible()5_ E G F P return reducible(function())5_ F H G P ! return reducible(function() {})5_ G I H P ! 5_ H J I P ! var reduce = require()5_ I K J P ! var reduce = require("")5_ J L K P " ! 5_ K M L P " var reducible = require()5_ L N M P " var reducible = require("")5_ M O N P *var transformer = require("./transformer")5_ N P O P &var transform = require("./transform")5_ O Q P P var reduce = require("./reduce")5_ P R Q P return reducible(function() {5_ Q S R ( P 5_ R T S P reduce()5_ S U T P reduce(source, function())5_ T V U ' P ) reduce(source, function(next, value))5_ U W V * P + reduce(source, function(result, value))5_ V X W , P . reduce(source, function(result, value) {})5_ W Y X P ! , reduce(source, function(result, value) {5_ X Z Y
P, ! 5_ Y [ Z P. # " 5_ Z \ [ P5 # 5_ [ ] \ P? # return count === 0 next()5_ \ ^ ] ! PR # " return count === 0 next(res)5_ ] _ ^ % Pe # & return count === 0 next(reduced)5_ ^ ` _ & Pf # ( return count === 0 next(reduced())5_ _ a ` - Pi # . return count === 0 next(reduced(result))5_ ` b a 0 P| # 0 return count === 0 next(reduced(result), )5_ a c b v P # var count = n5_ b d c v P $ # 5_ c e d v P $ "var reduced = require("./reduced")5_ d f e v P $ !var reduce = require("./reduced")5_ e g f
v P $
return 5_ f h g v P $ return count === 0 ? 5_ g i h v P $ return count > 0 ? 5_ h j i v P $ return count > 0 ? next()5_ i k j , v P $ , return count > 0 ? next(value, result)5_ j l k v P / return transformer(source, function(source) {5_ k m l v P % var count = n >= 0 ? n : Infinity5_ l n m v P < return transform(source, function(next, value, result) {5_ m o n v P count = count - 15_ n p o v P A return count === 0 ? next(reduced(), next(value, result)) :5_ o q p
v P . count > 0 ? next(value, result) :5_ p r q v P 0 next(reduced(), result)5_ q s r v P })5_ r t s v P })5_ s u t % v P! . return count > 0 ? next(value, result) :5_ t v u $ v P" ' return count > 0 ? next(result) :5_ u w v v P= . return count > 0 ? next(result, value) :5_ v x w v PC / return count => 0 ? next(result, value) :5_ w y x v PD . return count > 0 ? next(result, value) :5_ x z y v Pr result5_ y { z v P , return reducible(function(next, initial) {5_ z | { " v P 3 return reduce(source, function(result, value) {5_ { } | 2 v P/ 5_ | ~ } v P3 console.log()5_ } ~ v P3 console.log("")5_ ~ v P5 console.log(">>")5_ v P7 console.log(">>", result)5_ $ v P9 5_ v PM & console.log(">>", result, value)5_ v PN 5_ v PP ! })5_
v P/ 5_ v P3 console.log()5_ v P3 " console.log("")5_ v P 5_ v P var reduced = require()5_ v P # var reduced = require("")5_ v P result5_ ( v P % ( reduced(result5_ v P; 5_ v PE & 5_ v PI / return count >= 0 ? next(result, value) :5_ . v PK " count === 0 ? reduced . return count > 0 ? next(result, value) :5_ # v PY $ count === 0 ? reduced()5_ 1 v P] 1 count === 0 ? reduced(result, value)5_ v Pb ' ) reduced(result)5_ 0 + v + Ps + 3 count === 0 ? reduced(result, value) :5_ + v + Pw , console.log(">>>")5_ 4 v PB : print(take([ 1, 2, 3, 4, 5 ], 2)) // => 5_ 4 v PE < print(take([ 1, 2, 3 ], 5)) // => 5_ 5 v PH 6 print(take([ 1, 2, 3 ], 5)) // => < 1 2 3 />5_ 3 v PI - 4 print(take([ 1, 2, 3, 4, 5 ], 2)) // => < 1 2 />5_ v P~
"use strict"; var reduce = require("./reduce") "var reduced = require("./reduced") &var reducible = require("./reducible") function take(source, n) { /** H Returns sequence of first `n` items of the given `source`. If `source` J contains less items than `n` then that's how much items return sequence will contain. ## Example 3 print(take([ 1, 2, 3, 4, 5 ], 2)) // => < 1 2 > 5 print(take([ 1, 2, 3 ], 5)) // => < 1 2 3 > **/ 7 return reducible(function reduceTake(next, initial) { % var count = n >= 0 ? n : Infinity D return reduce(source, function reduceTakeSource(result, value) { count = count - 1 . return count > 0 ? next(result, value) : 9 count === 0 ? reduced(next(result, value)) : reduced(result) }, initial) }) } module.exports = take5_ v P~
5_ v P~
function take
! 5_ v P~
" function take()5_ v P~
" function take(source, n)5_ v P~ " function take(source, n) {}5_ v P~ $ # 5_
v P~ $ return reduced()5_
v P~ $ return reduced)5_
v P~ $ return reducible()5_
v P~ $ return reducible(function())5_
v P~ $ ! return reducible(function() {})5_
v P~ % return reducible(function() {5_
( v P~ % + return reducible(function(next, source) {5_
( v P~
&
% 5_ v P~
& accumulate()5_ ! v P~
& " accumulate(source, function())5_ # v P~
& % accumulate(source, function() {})5_ v P~
' })5_ v P~
' # accumulate(source, function() {5_ , v P~
' 5_ v P~
( 5_
v P~
)
( 5_
v P~ ) 5_ v P~
) count = count - 15_ v P~ 5_
" $ / v / P ) return co5_ $ & / v / P;
+ 0 accumulate(source, function(value, result) {5_ . $ & / v / PA
+ ? accumulate(source, function accumulateTake(value, result) {5_ $ & / v / PI + 0 next(reduced(), result)5_ $ & / v / PK + # next(reduced(), result)5_ $ & / v / Pp , + 5_
% ' / v / Py
-
, 5_ & ( / v / P~
- result = next()5_ & ( / v / P return isReduced . - 5_ ( * / v / P / return isReduced()5_ ( * / v / P / return isReduced(result)5_ ( ( * / v / P 0 / 5_ ! ) + / v / P 0 ! count === 0 ? next()5_ # ) + / v / P 0 $ count === 0 ? reduced()5_ * ) + / v / P 0 * count === 0 ? reduced(result)5_ * , / v / P A return count === 0 ? next(reduced(), next(value, result)) :5_
) + / v / P . count > 0 ? next(value, result) :5_
( * / v / P $ next(reduced(), result)5_ ' ) / v / P . "var reducer = require("./reducer")5_ " ' ) / v / P . $var reducible = require("./reducer")5_ ' ) / v / P *var transformer = require("./transformer")5_ & ( / v / P &var transform = require("./transform")5_ % ' / v / P 5_ $ & / v / P "var reduced = require("./reduced")5_ # % / v / P + * 5_ $ & / v / P + var accumulate = require()5_ $ & / v / P + var accumulate = require("")5_ % $ & / v / P , + 5_ % ' / v / P , var isReduced = require()5_ % ' / v / P . , var isReduced = require("")5_ " % ' / v / P - , 5_ & ( / v / P - var reduced = require()5_ & ( / v / P / - var reduced = require("")5_ ! v P( .
- 5_ 4 " + v P, 7 : print(take([ 1, 2, 3, 4, 5 ], 2)) // => 5_ 4 " + v P. 7 < print(take([ 1, 2, 3 ], 5)) // => 5_ 5 v P4 ! ! ! 7 function take(source, n) { /** H Returns sequence of first `n` items of the given `source`. If `source` J contains less items than `n` then that's how much items return sequence will contain. ## Example : print(take([ 1, 2, 3, 4, 5 ], 2)) // => < print(take([ 1, 2, 3 ], 5)) // => **/ / return transformer(source, function(source) { % var count = n >= 0 ? n : Infinity < return transform(source, function(next, value, result) { count = count - 1 A return count === 0 ? next(reduced(), next(value, result)) : . count > 0 ? next(value, result) : 0 next(reduced(), result) }) }) } 5_ v P4 0 5_ 5 v PO 6 print(take([ 1, 2, 3 ], 5)) // => < 1 2 3 />5_ 3 v PP 3 4 print(take([ 1, 2, 3, 4, 5 ], 2)) // => < 1 2 />5_ v PX ! 5_ " " v P[ 4
if C5_ ! ! v Ps console.log " ! 5_ # # v Pv 7 # console.log()5_ # # v P 8 # console.log(value, result)5_ & v & P # ' console.log("<<<", value, result)5_ & v & P 5_ & v & P 5_ & v & P 9 " ! 5_ & & v & P : " ' console.log("<<<", value, result)5_ & v & P0 " , count === 0 ? reduced(result) :5_ & v & PP 5_ & v & PR . console.log("<<<", value, result, count)5_ & v & PR ! 5_
& v & PT ! if ()5_ & v & PV ! if (isReduced())5_ & v & PX ! if (isReduced(result))5_ & v & PY ! if (isReduced(result))5_ # & v & P\ ! # if (isReduced(result)) return5_ ) & v & P] " ! 5_
& v & Pe " if ()5_ & v & Ph " if (count === 0)5_ & v & Pk " if (count === 0) {}5_ & v & Pl $ # 5_ & v & Pn }5_ & v & Po # if (count === 0) {5_ & v & Pr # if (count === 0) 5_ & v & Ps # if (count !== 0) 5_ # & v & Pw $ # 5_ & v & P $ next()5_ & v & P % $ 5_
& v & P % return result5_ & v & P % return reduced(result5_ & v & P 5_ & v & P 5_
& v & P ) return isReduced(result) ? result :5_
& v & P ? count === 0 ? next(end, result), reduced(result) :5_
& v & P result5_
& v & P ! 5_
& v & P ! var end = require()5_
& v & P ; ! var end = require("")5_ & v & P ! $ if (count !== 0) return result5_ & v & P < ! # if (count >= 0) return result5_ & v & P " ! 5_
& v & P " if ()5_ & v & P if (count)5_ & v & P " ! 5_
& v & P " if ()5_ & v & P > if (count)5_ & v & P ? ! " if (count > 0) return result5_ & v & P @ ! # if (count >= 0) return result5_ & v & P# ! & var count = n >= 0 ? n : Infinity5_ & v & P% " ! 5_ & v & P' " if ()5_
& v & P) " if (count)5_ & v & P+ A " if (count === 0)5_ ! & v & PR if (count === 0) return []5_ " ! & v & PT D ! , return reducible(function(next, initial) {5_ ! # " & v & Pl ! ; return n === 0 ? [] : reducible(function(next, initial) {5_ " $ #
& v & Po ! 8 if (n === 0 ? [] : reducible(function(next, initial) {5_ # % $ & v & Pp ! 9 if (n === 0) ? [] : reducible(function(next, initial) {5_ $ & % & v & Ps ! > if (n === 0) return [] : reducible(function(next, initial) {5_ % ' & & v & Pv # " 5_ & ( ' & v & P| E # // If take `0` 5_ ' ) ( & v & P # if (n === 0) return []5_ ( * ) & v & P F # if (n === 0) return void()5_ ) + * 4 & v & P G # 4 // If take `0` then optimize by returning an empty5_ * , + & v & P $ # 5_ + - , & v & P 5_ , . - & v & P # 5_ - / . & v & P $ 5_ . 0 / & v & P $ % var count = n >= 0 ? n : Infinity5_ / 1 0 & v & P H $ 5_ 0 2 1 & v & P % $ 5_ 1 3 2 & v & P % if ()5_ 2 4 3 & v & P % if (n < 0)5_ 3 5 4 $ & v & P I % $ var count = n > 0 ? n : Infinity5_ 4 6 5 5 & v & P % 5 // If take `0` then optimize by returning an empty.5_ 5 7 6 & v & P & 5_ 6 8 7 & v & P J ' // then just return 5_ 7 9 8 7 & v & P K ' 7 // Normalize count, if less then zero use infinity.5_ 8 : 9 ! & v & PF ! ) ! ( 5_ 9 A : ! & v & Pa " ) * if (isReduced(result)) return result5_ : B ; A ? & v & P ! ) E // If consumer does not even wants that much just return result5_ A C B F & v & P M " // as it " ) F // If consumer does not even wants that much just return `result5_ B K C " + & v & P " $ + " $ * 5_ C L D K # & v & P " $ + ( // If we have not reached `n` yet.5_ K M L # & & v & P " $ + & // If we have not taken `n` yet.5_ L N M $ ! & v & P $ & + 5_ M O N % & v & P % ' - % ' , 5_ N P O & $ & v & P % ( - $ // If got this far this means 5_ O Q P ' % & v & P< & ( . % // for pass `end` of stream to 5_ P R Q ' B & v & PF & ( . B // for pass `end` of stream to consumer to signal it's done.5_ Q S R ' @ & v & PI N ' ) L // accumulated `result` boxed in a `reduced` to notify `source` we don & ) . @ // for pass `end` of stream to consumer to signal the end.5_ R T S * v Py ) + 0 next(end, result)5_ S U T + v P{ O * + return reduced(result)5_ T V U " ( v P P ! # / 7 if (isReduced(result) || count > 0) return result5_ U W V ! v P ! / 5_ V X W # v P " $ 0 * if (isReduced(result)) return result5_ W Y X # v P " $ 0 1 return if (isReduced(result)) return result5_ X Z Y # v P " $ 0 - return isReduced(result)) return result5_ Y [ Z # ( v P " $ 0 . return isReduced(result) ? return result5_ Z \ [ # ' v P " $ 0 ' return isReduced(result) ? result5_ [ ] \ %
v P $ & 0 " if (count > 0) return result5_ \ ^ ] % v P $ & 0 % count > 0) return result5_ ] _ ^ % v P $ & 0 & count > 0 ? return result5_ ^ ` _ % v P $ & 0 count > 0 ? result5_ _ a ` # v P # % 0 5_ ` b a % v P % ' 1 5_ a c b & v P % ' 2 //5_ b d c " v P " $ 3 // " $ 2 5_ c e d .
v P - / 3 return next(end, result)5_ d f e - v P , . 3 // need more items.5_ e g f - v P - / 4 // - / 3 5_ f h g # v P Q " # 5_ g i h ! v P ! G // If consumer does not even wants that much just return `result`5_ h j i ! v P ! , // as it's already boxed into reduced.5_ i k j !
v P " 1 ) return isReduced(result) ? result :5_ j l k ! ! ! v P " 1
return 5_ k m l ! ! ! v P ! 5_ l n m ! ! ! v P! ! 5_ m o n # ! ! v P" " $ / ! count > 0 ? result :5_ n p o # ! ! v P# " $ / ' return count > 0 ? result :5_ o q p " ! ! v P' ! " 5_ p r q # ! ! v P+ " # 5_ q s r # ! ! v P, " $ - M // If got this far this means `n` items have already being passed there5_ r t s ! B ! ! v P. # - B // If we have not taken `n` items yet just pass result back.5_ s u t " ! ! v PO ! # . ! // pass `end` toa consumer 5_ t v u " ! ! v PP ! # . // pass `end` to consumer 5_ u w v "
! ! v PV ! # . // pass `end` to consumer 5_ v x w " ! ! v P^ ! # . ' // communicate `end` to consumer 5_ w y x " 1 ! ! v P` ! # . 1 // communicate `end` of stream to consumer 5_ x z y " ! ! v Pl ! # . & // communicate `end` of stream t5_ y { z " ! ! v Pp ! $ . // pass `end` of stream t5_ z | { # ! ! v P " $ / // reduced5_ { ~ | # ! ! v P " $ / // `reduced5_ | } ~ % ! ! v P $ % O // If got this far this means `n` items have already being passed there5_ ~ % ! ! v P $ % L // for pass `end` of stream to consumer to signal the end. Also return5_ % ! ! v P $ % N // accumulated `result` boxed in a `reduced` to notify `source` we don't5_ % ! ! v P $ % // need more items.5_ % ! ! v P $ % 5_ % ! ! v P % ' * 5_ & ! ! v P R % & 5_ ! ! v P S 'var isReduced = require("./is-reduced")5_ v P T "var reduced = require("./reduced")5_ # v P U " $ ( next(end, result)5_ # v P V " $ ( next(end)5_ v P W ( , return reducible(function(next, initial) {5_ PJ ( &var reducible = require("./reducible")5_ PJ ( (var accumulate = require("./accumulate")5_ . PJ ( 0var accumulate = require("reducible/accumulate")5_ PJ X ( ,var accumulate = require("reducible/reduce")5_ PJ ( E accumulate(source, function accumulateTakeSource(value, result) {5_
PJ ( A reduec(source, function accumulateTakeSource(value, result) {5_ & PJ Y ( A reduce(source, function accumulateTakeSource(value, result) {5_ & PJ ( ; return reducible(function accumulateTake(next, initial) {5_ " PJ ( 7 return reducible(function reduecTake(next, initial) {5_ " PJ ( 7 return reducible(function reduecTake(next, initial) {5_ " PJ Z ( 7 return reducible(function reduecTake(next, initial) {5_ PK- [ ( var end = require("./end")5_ PY (
"use strict"; .var reducible = require("reducible/reducible") (var reduce = require("reducible/reduce") "var end = require("reducible/end") function take(source, n) { /** H Returns sequence of first `n` items of the given `source`. If `source` J contains less items than `n` then that's how much items return sequence will contain. ## Example 3 print(take([ 1, 2, 3, 4, 5 ], 2)) // => < 1 2 > 5 print(take([ 1, 2, 3 ], 5)) // => < 1 2 3 > **/ E // If take `0` then optimize by returning an empty if less then `0` $ // then just return `source` back. if (n === 0) return void(0) if (n < 0) return source 7 return reducible(function reduceTake(next, initial) { J // Capture `n` into count, since modifying `n` directly will have side # // effects on subsequent calls. var count = n = reduce(source, function reduceTakeSource(value, result) { count = count - 1 " result = next(value, result) L // If we have not taken `n` items yet just pass result back. Otherwise I // pass `end` of stream to a consumer. Note `reducible` will return @ // `reduced(result)` back signaling source it should stop. ! return count > 0 ? result : next(end) }, initial) }) } module.exports = take5_ PZ (
"use strict"; &var reducible = require("./reducible") (var accumulate = require("./accumulate") var end = require("./end") function take(source, n) { /** H Returns sequence of first `n` items of the given `source`. If `source` J contains less items than `n` then that's how much items return sequence will contain. ## Example 3 print(take([ 1, 2, 3, 4, 5 ], 2)) // => < 1 2 > 5 print(take([ 1, 2, 3 ], 5)) // => < 1 2 3 > **/ E // If take `0` then optimize by returning an empty if less then `0` $ // then just return `source` back. if (n === 0) return void(0) if (n < 0) return source ; return reducible(function accumulateTake(next, initial) { J // Capture `n` into count, since modifying `n` directly will have side # // effects on subsequent calls. var count = n E accumulate(source, function accumulateTakeSource(value, result) { count = count - 1 " result = next(value, result) L // If we have not taken `n` items yet just pass result back. Otherwise I // pass `end` of stream to a consumer. Note `reducible` will return @ // `reduced(result)` back signaling source it should stop. ! return count > 0 ? result : next(end) }, initial) }) } module.exports = take5_ | ~ } $ ! ! v P # % 5_ C F K D # ( & v & P " $ + ' // If we have not reached `n` yet5_ D G E F & v & P + var count = 05_ F H G & v & P + count = count + 15_ G I H " ( & v & P ! # + * if (isReduced(result)) return result5_ H J I $ & v & P # % + $ if (count === 0) return result5_ I J $ & v & P # % + $ if (count === n) return result5_ D F E & v & P 5_ : < A ; " & v & Pn ! # 5_ ; = < 2 & v & Pt ! ( @ // If consumer does not even more items just return result5_ < > = @ & v & Pw ! ( L // If consumer does not even more items or if we exceeded a limit just // return `5_ = ? > L & v & P ! ) C // If consumer does not even more items or if we exceeded `n`5_ > @ ? C & v & P ! ) H // If consumer does not even more items or if we exceeded `n` just5_ ? @ ! & v & P L " ) // return result.5_ & v & P7 B " J else accumulate(source, function accumulateTakeSource(value, result) {5_ & v & P = ! # if (count >= 0) return result5_ & v & PG 5_ & v & PH 5_ & v & PI ! if ()5_
& v & PK ! if (isRe)5_ # # v P 6 # + count >= 0 ? reduced(result) :5_
v P $var reducer = require("./reducible")5_ " v P 2 "var reducer = require("./reducer")5_ # # v P ! 8 return reducer(source, function(next, value, result) { next(f(value), result) })5_ $ $ v P # 5_ + v + Py * 5_ 3 5 6 4 v Pq
function drop(source, n) { /** / Reduces given `reducible` to first `n` items. **/ / return transformer(source, function(source) { var count = n >= 0 ? n : 1 < return transform(source, function(next, value, result) { $ return count -- > 0 ? result : / next(value, result) }) }) }5_ 4 5 v P
* B Drops first n characters from s. Returns an empty string if n is greater than the length of s.5