aTHBii2`b M/ *QK#BM2`b

S`HH2H S`Q;`KKBM; BM a+H

H2FbM/` S`QFQT2+
.i@S`HH2H #bi`+iBQMb

q2 rBHH bim/v i?2 7QHHQrBM; #bi`+iBQMb,

! Bi2`iQ`b
! bTHBii2`b
! #mBH/2`b
! +QK#BM2`b
Ai2`iQ`

h?2 bBKTHB}2/ Iterator i`Bi Bb b 7QHHQrb,

trait Iterator[A] {
def next(): A
def hasNext: Boolean
}

def iterator: Iterator[A] // on every collection

Ai2`iQ`

h?2 bBKTHB}2/ Iterator i`Bi Bb b 7QHHQrb,

trait Iterator[A] {
def next(): A
def hasNext: Boolean
}

def iterator: Iterator[A] // on every collection

h?2 Bi2`iQ` +QMi`+i,

! next +M #2 +HH2/ QMHv B7 hasNext `2im`Mb true

! 7i2` hasNext `2im`Mb false- Bi rBHH Hrvb `2im`M false
lbBM; Ai2`iQ`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi foldLeft QM M Bi2`iQ`\

def foldLeft[B](z: B)(f: (B, A) => B): B

lbBM; Ai2`iQ`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi foldLeft QM M Bi2`iQ`\

def foldLeft[B](z: B)(f: (B, A) => B): B = {

var s = z
while (hasNext) s = f(s, next())
s
}
aTHBii2`

h?2 bBKTHB}2/ Splitter i`Bi Bb b 7QHHQrb,

trait Splitter[A] extends Iterator[A] {

def split: Seq[Splitter[A]]
def remaining: Int
}

def splitter: Splitter[A] // on every parallel collection

aTHBii2`

h?2 bBKTHB}2/ Splitter i`Bi Bb b 7QHHQrb,

trait Splitter[A] extends Iterator[A] {

def split: Seq[Splitter[A]]
def remaining: Int
}

def splitter: Splitter[A] // on every parallel collection

h?2 bTHBii2` +QMi`+i,

! 7i2` +HHBM; split- i?2 Q`B;BMH bTHBii2` Bb H27i BM M mM/2}M2/ bii2

! i?2 `2bmHiBM; bTHBii2`b i`p2`b2 /BbDQBMi bm#b2ib Q7 i?2 Q`B;BMH bTHBii2`
! remaining Bb M 2biBKi2 QM i?2 MmK#2` Q7 `2KBMBM; 2H2K2Mib
! split Bb M 2{+B2Mi K2i?Q/ Ĝ P(HQ; M) Q` #2ii2`
lbBM; aTHBii2`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi fold QM  bTHBii2`\

def fold(z: A)(f: (A, A) => A): A

lbBM; aTHBii2`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi fold QM  bTHBii2`\

def fold(z: A)(f: (A, A) => A): A = {

if (remaining < threshold) foldLeft(z)(f)
lbBM; aTHBii2`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi fold QM  bTHBii2`\

def fold(z: A)(f: (A, A) => A): A = {

if (remaining < threshold) foldLeft(z)(f)
else {
val children = for (child <- split) yield task { child.fold(z)(f) }
children.map(_.join()).foldLeft(z)(f)
}
}
"mBH/2`

h?2 bBKTHB}2/ Builder i`Bi Bb b 7QHHQrb,

trait Builder[A, Repr] {

def +=(elem: A): Builder[A, Repr]
def result: Repr
}

def newBuilder: Builder[A, Repr] // on every collection

h?2 #mBH/2` +QMi`+i,

! +HHBM; result `2im`Mb  +QHH2+iBQM Q7 ivT2 Repr- +QMiBMBM; i?2

2H2K2Mib i?i r2`2 T`2pBQmbHv //2/ rBi? +=
! +HHBM; result H2p2b i?2 Builder BM M mM/2}M2/ bii2
lbBM; "mBH/2`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi i?2 filter K2i?Q/ mbBM; newBuilder\

def filter(p: T => Boolean): Repr

lbBM; "mBH/2`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi i?2 filter K2i?Q/ mbBM; newBuilder\

def filter(p: T => Boolean): Repr = {

val b = newBuilder
for (x <- this) if (p(x)) b += x
b.result
}
*QK#BM2`

h?2 bBKTHB}2/ Combiner i`Bi Bb b 7QHHQrb,

trait Combiner[A, Repr] extends Builder[A, Repr] {

def combine(that: Combiner[A, Repr]): Combiner[A, Repr]
}

def newCombiner: Combiner[T, Repr] // on every parallel collection

h?2 +QK#BM2` +QMi`+i,

! +HHBM; combine `2im`Mb  M2r +QK#BM2` i?i +QMiBMb 2H2K2Mib Q7

BMTmi +QK#BM2`b
! +HHBM; combine H2p2b #Qi? Q`B;BMH Combinerb BM M mM/2}M2/ bii2
! combine Bb M 2{+B2Mi K2i?Q/ Ĝ P(HQ; M) Q` #2ii2`
lbBM; *QK#BM2`b

Zm2biBQM, >Qr rQmH/ vQm BKTH2K2Mi  T`HH2H filter K2i?Q/ mbBM;

splitter M/ newCombiner\