VimUnDo _-H5`?Gʄ%9Bnq =3d{ % ) X X X X PZ _ V P 5_ V P 5_ % % V P % 5_ & & V P ' * & 5_ ( ( V P
( ! items in the `right` sequences.5_ ( ( V P 7 The reducing function for append (below). Not public.5_ ' ' V P ' function append1(left, right) {5_
' ' V P' ' &var transform = require("./transform")5_
" ' ' V P. ' $var convert = require("./transform")5_
' ' V P0 ( ' 5_
( ( V P4 ( var accumulate = require()5_
( ( V P4 ( var accumulate = require("")5_
' ( ( V PB ) ( 5_
) ) V PE ) var end = require()5_ ) ) V PE ) var end = require("")5_ % v P_
) function map(source, f) { /** E Returns transformed version of given `source` where each item of it is mapped using `f`. ## Example / 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 Pb module.exports = map5_ v Pp " 5_ v Ps % $function append(left, right, rest) {5_ v P % 5_ v P 5_ v P var slicer = require &
% 5_
v P ' var slicer = require()5_
v P
' var slicer = require("")5_ v P ' ; return rest ? slice(arguments, 1).reduce(append1, left) :5_ v P ( ' 5_
v P ( switch ()5_ v P ( switch (arguments.length)5_ v P ( switch (arguments.length) {}5_ v P ! * ) 5_ v P " , " + 5_ ! !
v P ! # - ! # , 5_ " ! " v P ! # - return append1()5_ ! # " " v P ! # - return append()5_ " $ # " v P " $ . " $ - 5_ # % $ v P . case 1: return left ! . return left5_ $ & % ! v P ! - case 2: return append(left, right) " - return append(left, right)5_ % ' & ! v P # , default5_ & ( ' ! v P " - default:5_ ' ) ( ! v P " - default: slicer.call()5_ ( * ) ! & v P " - & default: slicer.call(arguments, 1)5_ ) + * ! % v P " - / default: slicer.call(arguments, 1).reduce()5_ * , + ! + v P " - , default: slicer.call(arguments).reduce()5_ + - , " v P ! " 5_ , . - # v P " # A return rest ? slicer.call(arguments, 1).reduce(append1, left) :5_ - / . # v P " # $ append1(left, right)5_ . 0 / v P * $function concat(left, right, rest) {5_ / 1 0 v P * %function concat(left, right, /rest) {5_ 0 2 1 ! v P" * (function concat(left, right /*, /rest) {5_ 1 3 2 ' v P% * *function concat(left, right /*, ...rest) {5_ 2 4 3 $ v P2 # % * exports.append = append5_ 3 5 4 $ v P5 # $ exports.append = concat5_ 4 6 5 $ v P6 # $ 5_ 5 7 6 $ v P6 # $ 5_ 6 8 7 & v P8 % & 5_ 7 9 8 & v P8 % & 5_ 8 : 9 ! v P " % 2 default: slicer.call(arguments).reduce(append)5_ 9 ; : v P & * % 5_ : < ; v P & Z Returns a lazy seq representing the concatenation of the elements in the supplied colls.5_ ; = < v P & U Returns a seq representing the concatenation of the elements in the supplied colls.5_ < > = K v P & Z Returns a sequence representing the concatenation of the elements in the supplied colls.5_ = ? > v P ' supplied colls.5_ > @ ? v P ' 5_ ? B @ v P ( supplied arguments.5_ @ C A B v P" 5_ B D C v P" N Concatenate multiple `reducible`s, returning a single `reducible` containing5_ C E D v P# 9 all the items from the original `reducibles`, in order.5_ D F E v P$ & % 5_ E G F v P1 ( ' 5_ F H G v P4 ( & append([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])5_ G I H v P7 ( & concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])5_ H J I , v P9 ( , print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])5_ I K J - v P: ( - print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ]))5_ J L K 4 v PJ ( 4 print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => 5_ K M L 6 v PM ( H print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => [ 1, 2, 3, 4, 5, 6 ]5_ L N M = v PP ( N print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => , v , Pl
$ ? when(reduce(left, next, initial), function reduceRight() {}5_ 7 9 8 , v , Pl
% > when(reduce(left, next, initial), function reduceRight() {5_ 8 : 9 , v , Pl % }5_ 9 ; : ' v ' Pl % ( return reduce(right, next, result)5_ : < ; ' v ' Pl 5 return reduce(, function reduceRight(_, result) {5_ ; = < ' v ' Pl 5_ < > = ' v ' Pl })5_ = ? > ' v ' Pl # " 5_ > @ ? B ' v ' Pl
# E return when(reduce(left, next, initial), function reduceRight() {5_ ? A @ v G Pl $ # 5_ @ B A v G Pl $ var when = require()5_ A C B v G Pl E $ var when = require("")5_ B D C v G P % $ 5_ C E D v G P! F % console.log()5_ D F E v G P% G % console.log(result)5_ E G F v G P & % 5_ F H G v G P & var leftResult = reduce()5_ G I H & v G P & ' var leftResult = reduce(function())5_ H J I ( v G P & * var leftResult = reduce(function() {})5_ I K J % v G P ' ( var leftResult = reduce(function() {5_ J L K v G P ' ( var leftResult = reduce(function() {5_ K M L + v G P ' . var leftResult = reduce(left, function() {5_ L N M 8 v G P ' ; var leftResult = reduce(left, function(next, initial) {5_ M O N v G P ' })5_ N P O v G P ( ' 5_ O Q P 1 v G P& ( ; var leftResult = reduce(left, function(result, value) {5_ P R Q v G P* ( var state = 5_ Q S R v G P, ( }, next)5_ R T S v G P. ) ( 5_ S U T v G P3 ) state = next()5_ T V U v G P: * ) 5_ U W V + v G PC * K return when(reduce(left, next, initial), function reduceRight(result) {5_ V Y W v G PJ * 6 var leftResult = reduce(left, function(_, value) {5_ W Z X Y
v
PS * : return when(leftResult, function reduceRight(result) {5_ Y [ Z 3
v
Pf + * 5_ Z \ [
v
Ps + return state 5_ [ ] \
v
Pv + return isReduced(state 5_ \ ^ ]
v
Px , + 5_ ] _ ^
v
P| , var isReduced = require()5_ ^ ` _
v
P} H , var isReduced = require("")5_ _ a `
v
P reduce , return isReduced(state)5_ ` b a
v
P - reduce()5_ a c b
v
P console.log("!!", result)5_ b d c
v
P J ( return reduce(right, next, result)5_ c e d
v
P , + 5_ d f e
v
P K , console.log()5_ e g f 3
v
P L , 6 return when(result, function reduceRight(result) {5_ f h g
v
P N console.log(state)5_ g i h
v
P ? // aggregated in the outer scope variable, since result won , + 5_ h j i
v
PM O . // boxed. 5_ i l j (
v
P . 2 var result = reduce(left, function(_, value) {5_ j m k l )
v
P . 3 var result = reduce(left, function(re, value) {5_ l n m
v
P . })5_ m o n
v
P . state = next(state, value)5_ n p o
v
P . ! result = next(state, value)5_ o q p
v
P / . 5_ p r q
v
P / return isReduced()5_ q s r
v
P / return isReduced(result)5_ r t s
v
P 0 / 5_ s u t
v
P 0 var reduced = require()5_ t v u
v
P P 0 var reduced = require("")5_ u w v '
v
P 0 ) return isReduced(result) ? reduce()5_ v x w )
v
P 0 * return isReduced(result) ? reduced()5_ w y x 0
v
P 0 0 return isReduced(result) ? reduced(result)5_ x z y 8
v
P next 0 8 return isReduced(result) ? reduced(result) : value5_ y { z
v
P 1 next()5_ z | {
v
P return state5_ { } |
v
P Q var state = initial5_ | ~ } -
v
P / 0 return when(result, function reduceRight() {5_ } ~ 1
v
P
/ 4 return when(result, function reduceRight(rest) {5_ ~
v
P
/ ' return isReduced(state) ? state :5_ &
v
P / ( return isReduced(result) ? state :5_ &
v
P / . return isReduced(result) ? state.value :5_ %
v
P / - return isReduced(result) ? rest.value :5_ &
v
P$ R / ' reduce(right, next, state)5_
v
P5 0 / 5_
v
P= S 0 console.log()5_
v
P T 0 next(result, value)5_
v
P U console.log(result)5_
v
P
0
/ 5_
v
P
0 function reduceFirst()5_ #
v
P
0 #function reduceFirst(result, value)5_ %
v
P
0 &function reduceFirst(result, value) {}5_
v
P
1 %function reduceFirst(result, value) {5_
v
P 1 5_
v
P 3
2 5_
v
P 5 * 4 5_
5
v
P
boxed value then i 5 5 Reduces left branch of the concatenation such that 5_ J
v
P1
7 J boxed value this function will wrap it into `reduced` once again so that5_
v
P? 5_
v
PC 7 reducer of the right5_ ?
v
PZ 7 E reducer of the right branch that reductions is complete. Note that 5_ G
v
P] 7 G reducer of the right branch that reductions is complete. Please that 5_
v
Pj 8 result of reduce5_
v
Pk 8 result of `reduce5_ ;
v
Pw 8 K reducer of the right branch that reductions is complete. Please note that5_ K
v
Py 8 K reducer of the right branch that reductions is complete (Please note that5_
v
P result of `reduce` i5_
v
P 8 is unboxed5_
v
P 8
is unboxed 5_
v
P 8 is un-boxed 5_ >
v
P V 8 > is un-boxed so without double boxing it will appear unboxed.5_
v
P : 9 5_ v P
: /** I Reduces left branch of the concatenation. If consumer returns `reduced` L boxed value this function will wrap it into `reduced` once again to signal M reducer of the right branch that reductions is complete (result of `reduce` O is un-boxed so without double boxing right branch reducer function won't know result is already reduced. **/5_ v P
$function reduceLeft(result, value) {5_ v P
5_ v P
result = next()5_ v P
}5_ v P
5_ v P 0 / 5_ v P 6 I Reduces left branch of the concatenation. If consumer returns `reduced` L boxed value this function will wrap it into `reduced` once again to signal M reducer of the right branch that reductions is complete (result of `reduce` O is un-boxed so without double boxing right branch reducer function won't know result is already reduced. **/5_ & v P 6 7 var result = reduce(left, function(result, value) {5_ J v P 6 P boxed value this function will wrap it into `reduced` once again to signal5_ v P 7 signal Kreducer of the right branch that reductions is complete (result of `reduce` 7 Q reducer of the right branch that reductions is complete (result of `reduce`5_ M v P 6 X signal reducer of the right branch that reductions is complete (result of `reduce`5_ v P 7 of `reduce` Mis un-boxed so without double boxing right branch reducer function won't know 7 S is un-boxed so without double boxing right branch reducer function won't know5_ L v P 6 _ of `reduce` is un-boxed so without double boxing right branch reducer function won't know5_ v P W 7 function won't know result is already reduced. 7 result is already reduced.5_ v P C // Accumulated `state` for the reductions of the left branch is5_ v P D // aggregated in the outer scope variable, since result won't be5_ v P X ) // boxed. While we do want to box it.5_ v P [ 3 5_ - v P" 5 4 5_ 2 v P6 \ ! 5 2 // If result is already reduced no point in 5_ ! v PU 7 6 5_ v P^
8 function Concatination5_ v P_
8 function Concatination()5_ v P_
8 function Concatination() {}5_ v Pa
:
9 5_ v Pe ; : 5_ v Pj ]
; function Concatination() {5_ v Pr < ; 5_ v Pz < reduce.define()5_ ' v P} < (reduce.define(Concatination, function())5_ ) v P} < +reduce.define(Concatination, function() {})5_ v P = 5_ & v P > )reduce.define(Concatination, function() {5_ & v P > 6reduce.define(Concatination, function(Concatination) {5_ 3 v P ^ > 6reduce.define(Concatination, function(concatination) {5_ , v P > /** C Returns sequences of items in the `left` sequence followed by the items in the `right` sequence. **/ , return reducible(function(next, initial) { B var result = reduce(left, function reduceLeft(result, value) { /** M Reduces left branch of the concatenation. If consumer returns `reduced` I boxed value this function will wrap it into `reduced` once again to L signal reducer of the right branch that reductions is complete (result K of `reduce` is un-boxed so without double boxing right branch reducer 4 function won't know result is already reduced. **/ " result = next(result, value) 2 return isReduced(result) ? reduced(result) : result }, initial) 6 return when(result, function reduceRight(result) { < // If result is already reduced just return it's value > // otherwise return reduction value of the right branch. / return isReduced(result) ? result.value : ( reduce(right, next, result) }) })5_ v P * ' & 5_ - - v P _ @ ? 5_ 2 & v & P A var left = concatenation.left5_ 2 & v & P A ! var right = concatenation.right5_ . 2 & v & P - . function append(left, right) {5_ . 2 & v & P - . 5_ . 2 & v & P - . }5_ . 2 & v & P ` - . 5_ 8 2 & v & P 7 9 = & case 2: return append(left, right)5_ 8 * 2 & v & P a 7 9 = 7 case 2: return new Concatinationappend(left, right)5_ ; 2 & v & P b ; = > ; = = 5_ - 2 & v & P - / ? - / > 5_ . 2 & v & P - / ? function concatenation()5_ . 2 & v & P - 0 ? function concatenation() {}5_ / 2 & v & P - / @ function concatenation() { } . 0 @ }5_ . 2 & v & P - / ? function concatenation() {}5_ . % 2 & v & P - / ? &function concatenation(left, right) {}5_ . ? 2 & v & P - / ? Afunction concatenation(left, right) { return new Concatination()}5_ . K 2 & v & P c - / ? Lfunction concatenation(left, right) { return new Concatination(left, right)}5_ . K 2 & v & P d . 0 ? 5_ ; 8 2 & v & P e : < @ 9 default: return slicer.call(arguments).reduce(append)5_ ; 2 ; 2 ; > v > P8 f : < @ @ default: return slicer.call(arguments).reduce(concatination)5_ v PP
@ %function Concatination(left, right) {5_ v PR g @ Ereduce.define(Concatination, function(concatination, next, initial) {5_ . . . v PV - / @ Mfunction concatenation(left, right) { return new Concatination(left, right) }5_ . . . v PX - / @ Mfunction Concatenation(left, right) { return new Concatination(left, right) }5_ . > . . v PZ h - / @ Mfunction concatenation(left, right) { return new Concatination(left, right) }5_ : : : # v # P` i 9 ; @ 1 case 2: return new Concatination(left, right)5_ ; 2 ; 2 ; > v > Pc : < @ @ default: return slicer.call(arguments).reduce(concatenation)5_ ; 2 ; 2 ; > v > Pe : < @ @ default: return slicer.call(arguments).reduce(Concatenation)5_ > ; 2 ; > v > Pi = ? @ concat.type = Concatination5_
v Pr @ var left = concatination.left5_ v Pt @ ! var right = concatination.right5_ & & 2 v 2 Px j @ Ereduce.define(Concatenation, function(concatination, next, initial) {5_ % & 2 v 2 P l @ Ereduce.define(Concatenation, function(concatenation, next, initial) {5_ & 2 v 2 P , return reducible(function(next, initial) {5_ " v P # ? B var result = reduce(left, function reduceLeft(result, value) { /** M Reduces left branch of the concatenation. If consumer returns `reduced` I boxed value this function will wrap it into `reduced` once again to L signal reducer of the right branch that reductions is complete (result K of `reduce` is un-boxed so without double boxing right branch reducer 4 function won't know result is already reduced. **/ " result = next(result, value) 2 return isReduced(result) ? reduced(result) : result }, initial)5_ " v P m ? @ var result = reduce(left, function reduceLeft(result, value) {5_ $ $ ) v P # * ? 6 return when(result, function reduceRight(result) { < // If result is already reduced just return it's value > // otherwise return reduction value of the right branch. / return isReduced(result) ? result.value : ( reduce(right, next, result) })5_ * $ ) v P n ) * })5_ ( $ ) v P o ' ) > & reduce(right, next, result)5_ $ ) v P var left = concatenation.left5_ # ( v P p ! var right = concatenation.right5_ " ' v P = < 5_ # ( v P = console.log()5_ # ( v P q = console.log("")5_ # ( v P r = console.log(">>>>>")5_ , # ( v P= t = Lreduce.define(Concatenation, function reduce(concatenation, next, initial) {5_ # ( v PE u % console.log(">>>>>", concatenation)5_ * * * L v L Pd ) + < Mfunction concatenation(left, right) { return new Concatenation(left, right) }5_ * * * L v L Pe ) * 5_ * * * L v L Pe v ) * 5_ * * L v L Ph ; : 5_ + + L v L Pi w ; 5_ , , L v L Pk =
< 5_ . . L v L Pp ? * > 5_
M 0 0 L v L P @ M Concatenation is data structure representing concatenation of two sequences5_ 1 1 L v L P 5_ 0 0 L v L P
@ sequences.5_ 0 0 L v L P
@ sequences. Left one is stoe5_ 0 0 L v L P
@ sequences.5_
! 0 0 L v L P @ M Concatenation is data structure representing concatenation of two reducible5_
0 0 L v L P
@
sequences. 5_ 0 0 L v L P
@ & sequences. Type implements `reduce` 5_ . 0 0 L v L P x
@ . sequences. Type implements polymorp`reduce` 5_ & 0 0 L v L P @ Mfunction concatenation(left, right) { return new Concatenation(left, right) }5_
( 1 1 L v L P A ) return new Concatenation(left, right) }5_
2 2 L v L P B 5_
3 3 L v L P 5_
2 2 L v L P C B 5_
4 4 L v L P z E * D 5_
5 5 L v L P F * E 5_ ! 6 6 L v L P F 9 Implementation of `reduce` for Concatenation data types5_ 9 6 6 L v L P F 9 Implementation of `reduce` for concatenation data types5_ 9 6 6 L v L P F 9 Implementation of `reduce` for concatenation data type.5_ C 6 6 L v L P F C Implementation of `reduce` for concatenation data type. It reduce5_ ; 6 6 L v L P" F ; Implementation of `reduce` for concatenation data type. R5_ C 6 6 L v L P) F C Implementation of `reduce` for concatenation data type. It reduce5_ 6 6 L v L P- F = Implementation of `reduce` for concatenation data type. It @eturns sequences of items in the `left` sequence followed by the F C Returns sequences of items in the `left` sequence followed by the5_ O 5 5 L v L P0 E ~ Implementation of `reduce` for concatenation data type. It returns sequences of items in the `left` sequence followed by the5_ 6 6 L v L P1 { F 1 of items in the `left` sequence followed by the items in the `right` sequence. F items in the `right` sequence.5_ : ; 5 5 L v L PV 9 ; E J print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => 5_ : C 5 5 L v L PY } 9 ; E D print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => < 1 2 3 4 5 6 />5_ 5 5 L v L P}U E
"use strict"; &var reducible = require("./reducible") var reduce = require("./reduce") 'var isReduced = require("./is-reduced") "var reduced = require("./reduced") #var when = require("eventual/when") "var slicer = Array.prototype.slice %function Concatenation(left, right) { /** H Concatenation is data type representing concatenation of two reducible sequences. **/ this.left = left this.right = right } %function concatenation(left, right) { /** Concatenation type factory. **/ ' return new Concatenation(left, right) } Rreduce.define(Concatenation, function reduceConcat(concatenation, next, initial) { /** N Implementation of `reduce` for concatenation data type. It returns sequences P of items in the `left` sequence followed by the items in the `right` sequence. **/ N var result = reduce(concatenation.left, function reduceLeft(result, value) { /** K Reduces left branch of the concatenation. If consumer returns `reduced` G boxed value this function will wrap it into `reduced` once again to J signal reducer of the right branch that reductions is complete (result I of `reduce` is un-boxed so without double boxing right branch reducer 2 function won't know result is already reduced. **/ result = next(result, value) 0 return isReduced(result) ? reduced(result) : result
}, initial) 4 return when(result, function reduceRight(result) { : // If result is already reduced just return it's value < // otherwise return reduction value of the right branch. - return isReduced(result) ? result.value : 4 reduce(concatenation.right, next, result) }) }) ,function concat(left, right /*, ...rest*/) { /** J Returns a sequence representing the concatenation of the elements in the ) supplied arguments, in the given order. C print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => < 1 2 3 4 5 6 > **/ switch (arguments.length) { case 1: return left 1 case 2: return new Concatenation(left, right) @ default: return slicer.call(arguments).reduce(concatenation) } } concat.type = Concatenation module.exports = concat5_ 5 5 L v L P}h $ 5_ 6 6 L v L P}k % "var convert = require("./convert")5_ " 6 6 L v L P}o ~ % $var reducible = require("./convert")5_
6 6 L v L P}s % 5_
6 6 L v L P}x %
reducible()5_ !
6 6 L v L P}| % reducible(function())5_ " !
6 6 L v L P}| % reducible(function() {})5_ ! # "
7 7 L v L P} & reducible(function() {5_ " $ #
! 7 7 L v L P}
'
& 5_ # % $ 8 8 L v L P}
' accumulate()5_ $ & % 8 8 L v L P}
' accumulate(left, function())5_ % ' & ! 8 8 L v L P}
' # accumulate(left, function() {})5_ & ( ' 9 9 L v L P}
( ! accumulate(left, function() {5_ ' ) ( * 9 9 L v L P} ) ( 5_ ( * ) : : L v L P} * ) 5_ ) + * ; ; L v L P} * var end = require()5_ * , + ; ; L v L P} * var end = require("")5_ + - ,
; ; L v L P} *
return 5_ , . - ( ; ; L v L P} * ) return value === end ? accumulate()5_ - / . < ; ; L v L P} isError * < return value === end ? accumulate(right, next, result)5_ . 0 / < < < L v L P} + < return value === end ? accumulate(right, next, result)5_ / 1 0 < < L v L P} + isError()5_ 0 2 1 < < L v L P} + next()5_ 1 3 2 < < L v L P} 6 return convert(null, function(self, next, initial) {5_ 2 4 3 ; ; L v L P} . accumulate(left, function(value, result) {5_ 3 5 4 : : L v L P} ? return value === null ? accumulate(right, next, result) :5_ 4 6 5 9 9 L v L P} 1 next(value, result)5_ 5 7 6 8 8 L v L P} }, initial)5_ 6 8 7 7 7 L v L P} })5_ 7 ; 8 6 6 L v L P} % })5_ 8 < 9 ; 6 6 L v L P~
& % 5_ ; = < 7 7 L v L P~
& console.log()5_ < > = 7 7 L v L P~$ & console.log(value, result)5_ = ? > 7 7 L v L P~3
& % reducible(function(next, initial) {5_ > @ ? 7 7 L v L P~6 ( console.log(">>>>", value, result)5_ ? A @ 6 6 L v L P~N
&
% 5_ @ B A 7 7 L v L P~U
& function Concatination()5_ A C B 7 7 L v L P~U & function Concatination() {}5_ B D C v P~^
' function Concatination() {5_ C E D v P~_
' function Concatenation() {5_ D F E v P~p %function Concatenation(left, right) {5_ E G F v P~p }5_ F H G PB
% , return reducible(function(next, initial) {5_ G I H PB % . accumulate(left, function(value, result) {5_ H J I PB % (var accumulate = require("./accumulate")5_ I K J PB % &var reducible = require("./reducible")5_ J L K " PB % $var reduce = require("./accumulate")5_ K M L PB % #var reduce = require("./reducible")5_ L N M PB % var end = require("./end")5_ M O N PB % 9 accumulate(left, function reduceLeft(value, result) {5_ N P O ' PB % > return value === end ? accumulate(right, next, result) :5_ O Q P PL & % 5_ P R Q PL & console.log()5_ Q S R PL & console.log("")5_ R T S PM & console.log("<<<")5_ S U T PO % console.log("<<<", next, initial)5_ T V U ) v PU\ % +var reduce = require("reducible/reducible")5_ U W V & v PU] % (var reduce = require("reducible/reduec")5_ V X W v PY %
"use strict"; .var reducible = require("reducible/reducible") (var reduce = require("reducible/reduce") "var end = require("reducible/end") "var slicer = Array.prototype.slice function append(left, right) { /** C Returns sequences of items in the `left` sequence followed by the items in the `right` sequence. **/ @ return reducible(function reduceConcatination(next, initial) { 5 reduce(left, function reduceLeft(value, result) { : return value === end ? reduce(right, next, result) : next(value, result) }, initial) }) } ,function concat(left, right /*, ...rest*/) { /** J Returns a sequence representing the concatenation of the elements in the ) supplied arguments, in the given order. J print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => **/ switch (arguments.length) { case 1: return left & case 2: return append(left, right) 9 default: return slicer.call(arguments).reduce(append) } } module.exports = concat5_ W X v PZ %
"use strict"; &var reducible = require("./reducible") (var accumulate = require("./accumulate") var end = require("./end") "var slicer = Array.prototype.slice function append(left, right) { /** C Returns sequences of items in the `left` sequence followed by the items in the `right` sequence. **/ , return reducible(function(next, initial) { . accumulate(left, function(value, result) { > return value === end ? accumulate(right, next, result) : next(value, result) }, initial) }) } ,function concat(left, right /*, ...rest*/) { /** J Returns a sequence representing the concatenation of the elements in the ) supplied arguments, in the given order. J print(concat([ 1 ], [ 2, 3 ], [ 4, 5, 6 ])) // => **/ switch (arguments.length) { case 1: return left & case 2: return append(left, right) 9 default: return slicer.call(arguments).reduce(append) } } module.exports = concat5_ 8 : ; 9 6 6 L v L P} % next(result)5_ 9 : 6 6 L v L P} % next(result, value)5_ , & 2 v 2 P k @ Rreduce.define(Concatenation, function reduceConcat(concatenation, next, initial) {5_ - v P Z 4 ) return isReduced(result) ? result :5_ j l k
v
P . , reduce(stateright, next, state)5_ W Y X
v PL * , var = reduce(left, function(_, value) {5_ g h % v PMu $ $var reducible = require("./convert")5_ " % v PM{ $ &var reducible = require("./reducible")5_
% v PM $ 2 return reducible(function(self, next, initial) {5_
" % v PM ? $ , return reducible(function(next, initial) {5_ % v PM @
$ 5 return accumulate(left, function(value, result) {5_ g i h ? P6 $ ? return value === null ? accumulate(right, next, result) : isEror isEror()5_ h j i P6 % isError()5_ i k j P6# % & var isError = require()5_ j l k P6' & var isError = require("")5_ k m l P6' $ & #var isError = require("./is-error")5_ l n m P6. & isError(value)5_ m o n P6/ & isError(value) ? 5_ n p o P65 & ' var reduced = require()5_ o q p P69 ' var reduced = require("")5_ p r q P6: ' "var reduced = require("./reduced")5_ q s r P6@ ' ' isError(value) ? reduced()5_ r t s & P6D ' - isError(value) ? reduced(result)5_ s u t - P6F % ' / isError(value) ? reduced(result) :5_ t v u - P6_ ' ( console.log()5_ u w v P6b & ( console.log(value)5_ v x w P6 ' ( console.log('>>>>', value)5_ w y x P7 ( + console.log('>>>>', value, isError())5_ x z y ) P7 ( ( 0 console.log('>>>>', value, isError(value))5_ y { z ! P7 (
) 5_ z | {
P7 5_ { } |
P7
)
* * var 5_ | }
P7 < 5_ } ~ % v PI = 5_ } ~ & P7 ( ' isError(value) ? result) :5_ ~ % P7 ) ( % isError(value) ? value :5_ P8 * 5_ P;' 5_ P;' 5_ P;' 5_ P;/ 5_ P;0 5_ P;0 5_ P;0 5_ P;1 ! return reducible()5_ P;5 ! return reducible(function())5_ P;6 ! ! return reducible(function() {})5_ P;7 ! return reducible(function() { })5_ P;9 " , return reducible(function(next, initial) {5_ ' P;T " # var reducible = require()5_ P;Y # var reducible = require("")5_ P;Y # &var reducible = require("./reducible")5_ % v P;` # $ &var reducible = require("./reducible")5_ $ % v P;a + $ #var reducible = require("./reduce")5_ % v P;p $ % reduce()5_ % v P;s % ! reduce(right, next, reduce())5_ % v P;z % 4 reduce(right, next, reduce(left, next, initial))5_
% v P; , % var reduce = require("./reduce")5_ % v P; - % ; return reduce(right, next, reduce(left, next, initial))5_ % v P<` 5_ % v P< 2 5_ % v P@ $ % console.log()5_ % v P@ % console.log("")5_ % v P@ % console.log("!!!!!!!!!")5_ % v P@ 3 % ) console.log("!!!!!!!!!", e, result)5_ % v PA 4 % ) console.log("!!!!!!!!!", _, result)5_ % v PD % F return reduce([ reduce(left, next, initial), function(_, result) {5_ / % v PD 5 % H return reduce([ reduce(left, next, initial) ], function(_, result) {5_ 0 % v PE+ % F return reduce([ reduce(left, next, initial), function(_, result) {5_ % v PE. % D return reduce(reduce(left, next, initial), function(_, result) {5_ % v PE/ 6 % }, null)5_ % v PF 5_ % v PF" $ F return reduce([ reduce(left, next, initial), function(_, result) {5_ / % v PF% $ H return reduce([ reduce(left, next, initial) ], function(_, result) {5_ % v PF' 7 $ })5_ % v PF5 $ G return reduce([reduce(left, next, initial) ], function(_, result) {5_ / % v PF8 8 $ F return reduce([reduce(left, next, initial)], function(_, result) {5_ + % v PF: $ % ) // Left side may reduce to undefined 5_ % v PFW 5_ % v PFe $ R return reduce(right, next, reduce(left, next, initial)], function(_, result) {5_ R % v PFp $ : return reduce(right, next, reduce(left, next, initial)5_ % v PFv 5_ % v PFw 5_ : % v PFy " ; return reduce(right, next, reduce(left, next, initial))5_ ! v ! PF " @ return when(reduce(right, next, reduce(left, next, initial))5_ ! v ! PF " . return when(, reduce(left, next, initial))5_ ! v ! PF " , return when(reduce(left, next, initial))5_ , ! v ! PF " ? return when(reduce(left, next, initial), reduce(right, next5_ - ! v ! PF " 9 return when(reduce(left, next, initial), function() { reduce(right, next5_ ! v ! PF # reduce(right, next, 5_ 6 ! v ! PF # ? return when(reduce(left, next, initial), function(result) {5_ ! v ! PF # reduce(right, next, result5_ ! v ! PF # ! reduce(right, next, result)5_ ! v ! PF # ( return reduce(right, next, result)5_ ! v ! PF 9 # $ })5_ ! v ! PGQ $
% var Concatinated()5_ ! v ! PGX
% var Concatinated() {}5_ v PGX
% var Concatinated() { }5_ v PGy
& var Concatenated() {5_ v PG}
& var Concatenation() {5_ v PG
& var Concatenation(left, right) {5_ v PG
& ' this.left = left this.right = right5_ v PG
( %function Concatenation(left, right) {5_ v PG ( 5_ v PG
5_ v PG
( 5_ v PG
) * accumulate.define()5_
v PG * ,accumulate.define(Concatenation, function())5_
* v PG * -accumulate.define(Concatenation, function( ))5_
, v PG * +accumulate.define(Concatenation, function()5_
+ v PG * .accumulate.define(Concatenation, function() {}5_
- v PG * -accumulate.define(Concatenation, function() { }5_ v PG
+ })5_
* v PG + ;accumulate.define(Concatenation, function(Concatenation ) {5_
* v PG + ;accumulate.define(Concatenation, function(concatenation ) {5_
8 v PG + Iaccumulate.define(Concatenation, function(concatenation, next, initial) {5_
v PG + , var accumulate = require()5_
v PG , var accumulate = require("")5_
v PG , (var accumulate = require("./accumulate")5_ %
v PG , - accumulate()5_
v PG
5_
v PG
5_
v PG :
5_
v PH<
*
+ reduce.define()5_
v PHI
+ (reduce.define(Concatenation, function())5_ '
v PHO
+ +reduce.define(Concatenation, function() {})5_ )
v PHO
+ )reduce.define(Concatenation, function() { })5_ &
v PHS
, Creduce.define(Concatenation, function(concatenation, left, right) {5_ ?
v PHm , -
reduce()5_
v PHq - reduce(right, concatenation, )5_
v PH - reduce(concatenation, )5_
v PH - reduce(concatenation.left, )5_ @
v PH
- Ereduce.define(Concatenation, function(concatenation, next, initial) {5_
v PH - + reduce(concatenation.left, next, initial)5_
v PH - 0 when(reduce(concatenation.left, next, initial)5_ 0
v PH - < when(reduce(concatenation.left, next, initial), function()5_ <
v PH - ? when(reduce(concatenation.left, next, initial), function() {}5_ >
v PH - > when(reduce(concatenation.left, next, initial), function() { }5_
v PH . })5_
v PH . E return when(reduce(concatenation.left, next, initial), function() {5_
v PI 5_
v PI 5_
v PI 5_
v PI 5_
v PI 5_
v PI 5_
v PI 5_
v PI ; 5_
v PH . / 5_
P;( 5_ P;( 5_ P;( 5_ P;) 5_ P;* !
return redu5_ \ ^ e ] P2m $ % if ()5_ ] _ ^
P2o % if (value === null)5_ ^ ` _ P2s % if (value === null)5_ _ a ` P2t % if (value === null) {}5_ ` b a P2y % if (value === null) { }5_ a c b P2z & 5_ b d c P2| ' ( accumulate()5_ c d P2 ( accumulate(right, nexn)5_ Z \ [
P- $ 1 return convert, function(self, next, initial) {5_ @ B A v P ( # supplied arguments, given order.5