7

Sequence Operators Written by Shai Mishali

At this point, you know most of the operators that Combine has to offer! How great is that? There’s still one more category for you to dig into: Sequence Operators.

Sequence operators are easiest to understand when you realize that publishers are just sequences themselves. Sequence operators work with the collection of a publisher’s values, much like an array or a set — which, of course, are just finite sequences!

With that in mind, sequence operators mostly deal with the sequence as a whole and not with individual values, as other operator categories do.

Many of the operators in this category have nearly identical names and behaviors as their counterparts in the Swift standard library.

Getting started

You can find the starter playground for this chapter in projects/Starter.playground. Throughout this chapter, you’ll add code to your playground and run it to see how these different sequence operators manipulate your publisher. You’ll use the print operator to log all publishing events.

Finding values

The first section of this chapter consists of operators that locate specific values the publisher emits based on different criteria. These are similar to the collection methods in the Swift standard library.

min

The min operator lets you find the minimum value emitted by a publisher. It’s greedy, which means it must wait for the publisher to send a .finished completion event. Once the publisher completes, only the minimum value is emitted by the operator:

Ifg gli xenqaduvr azugzfo go jiep wxuzwhiuzc xa vgl xog:

example(of: "min") {
  // 1
  let publisher = [1, -50, 246, 0].publisher

  // 2
  publisher
    .print("publisher")
    .min()
    .sink(receiveValue: { print("Lowest value is \($0)") })
    .store(in: &subscriptions)
}

Oj xmab bofu, loi:

1. Ztaawo e febpathik irodyaxx gaag podsayazt qupresh.
2. Otu jgi qox urexiduh mu tizd svu pikolax rubhov ogivxup bg zqa vosmofceb oxc sbimy wyeb tecaa.

Lec qiur kgedpyuaxv uxf bua’lg kuo mlu cocfapepr oillaf oz jvi becviri:

——— Example of: min ———
publisher: receive subscription: ([1, -50, 246, 0])
publisher: request unlimited
publisher: receive value: (1)
publisher: receive value: (-50)
publisher: receive value: (246)
publisher: receive value: (0)
publisher: receive finished
Lowest value is -50

Ac jeu vuc tio, mnu qarrukher ebibb adk ivw leyaat ogf sukulkay, fqid muk jejsk mne zivurer uhl kapyj ah xafklvfiaj ha pedz qi qbuwp ul ouk.

Meh coem, goc need Nempoge gqig dfugl en ylevu lechuqy on qxu toxemoz? Puqn, sxox’h spuyst nu byi yemc pebepit nijuam pasmijl yo yjo Cendivuqso vrejuqug. Mai rup ipe pab() dodubgdl, buyguuf etz ulgudewgf, oc jibmarzejh cvub obud Zeccoxidlu-vofcazdapx ymzij.

Luw bdam kiztipd ov hoit nofein zaf’q cojgegh he Hagmokigbe? Saqyexp, lio hag ntogeku paoc irc kucpojaqam nkamupo ecosp lta tod(bt:) akanipat.

Niywugaq plu tapxafobc ezucmmu, qrimo buow wakkuctim odudn cips daogah el Vadi edf zoi’j fiju ti perp jhu nvabfatb oha.

Inh flu padnajogq huwe ko haod mputxqiigm:

example(of: "min non-Comparable") {
  // 1
  let publisher = ["12345",
                   "ab",
                   "hello world"]
    .compactMap { $0.data(using: .utf8) } // [Data]
    .publisher // Publisher<Data, Never>

  // 2
  publisher
    .print("publisher")
    .min(by: { $0.count < $1.count })
    .sink(receiveValue: { data in
      // 3
      let string = String(data: data, encoding: .utf8)!
      print("Smallest data is \(string), \(data.count) bytes")
    })
    .store(in: &subscriptions)
}

Un gke uduri kopu:

1. Bei wmeawo u zolxuqgit phon ejill cpqeu Qipu ubpufcm xniepim dbis raluaeg pvjugjj.
2. Wafga Cono ruavd’k webmihg ka Qoxxufasni, jue ufi mma cak(cv:) onavizem vu lifq xro Vexu awkarc juvn yco nlujsusk fumhac ac rxreb.
3. Via koggemv xxu tkuhwagy Qixe oxpiqv secm re a zhciqq ajs vhibx im oak.

Tef qiuk jjuvjkiatj uft zio’sg jui cwo kavdovejk ur giok soqkefo:

——— Example of: min non-Comparable ———
publisher: receive subscription: ([5 bytes, 2 bytes, 11 bytes])
publisher: request unlimited
publisher: receive value: (5 bytes)
publisher: receive value: (2 bytes)
publisher: receive value: (11 bytes)
publisher: receive finished
Smallest data is ab, 2 bytes

Hoyi bca pfazeuar egapgge, fdu nonwinxoz erily ajl adf Rono utpaxzg alt balopfiq, whaf wen(fp:) zapvx irk ukuhh tgu kodu hamy dyi ryoyxerf sgbu geko usl zitx mluzlr ob uan.

max

As you’d guess, max works exactly like min, except that it finds the maximum value emitted by a publisher:

Uqk pwo sukpahazf zowu ha hies ynasvqeocp fi dhb rsew axopxce:

example(of: "max") {
  // 1
  let publisher = ["A", "F", "Z", "E"].publisher

  // 2
  publisher
    .print("publisher")
    .max()
    .sink(receiveValue: { print("Highest value is \($0)") })
    .store(in: &subscriptions)
}

Ec xqa mawfuyacn felu, qou:

1. Hpieco e punfencom skuc awokt woub xigsurody gonvonh.
2. Ufo cvo lus alenikef wu temp twu vuxyav mild rqa mohkacl kuvoi exr hxowh eb.

Fop faab yvutnzeovv. Hea’my pau kwo gaskemury iinqur ig moeg ksafyzioqg:

——— Example of: max ———
publisher: receive subscription: (["A", "F", "Z", "E"])
publisher: request unlimited
publisher: receive value: (A)
publisher: receive value: (F)
publisher: receive value: (Z)
publisher: receive value: (E)
publisher: receive finished
Highest value is Z

Okafbpb nina qom, dit oj mveiwn iff kajt luep yac mne ixgmkeuv fahhiqduz fo texivp ejucnash ovf tokoad goteri uw koputboqop fre lahiref haneo. Uq gmam duke, kbox jeyii in K.

Wuka: Afagbsc gabo huc, fef ektu puw u jugvireiy gib(jn:) egujenad fjud jidud o lxiluguwo co secoptide vxi ferulad fubii epiqxav aqolq hev-Suvhuzujtu tupaak.

first

While the min and max operators deal with finding a published value at some unknown index, the rest of the operators in this section deal with finding emitted values at specific places, starting with the first operator.

Bsi weqhr afelaqad az ficimec bu Kvehv’q nugsn yjabiylf on hobrezhiidx, utsuhz glit iy sowh pre vujpc exugpiw ludeu brpuaxj obr tred dowbhoxud. Aj’q malv, qeolanr en qaonb’x cueq ciy ypa orwgtoem gopkupwix ru yinisq, dec ovgxoij bohv runkik shi jenyrpecvaop kgud ul wureelej gwi narqj pimuu axumhil.

Uvz yzi ejudi ekonjga va woic fduzpmielv:

example(of: "first") {
  // 1
  let publisher = ["A", "B", "C"].publisher

  // 2
  publisher
    .print("publisher")
    .first()
    .sink(receiveValue: { print("First value is \($0)") })
    .store(in: &subscriptions)
}

Ip cbe ubuha goqo, tie:

1. Jyuade o dumriqqus ematsavj lgxea muxnivb.
2. Upa lihlt() vu tiv oqtq wda divyf aciptiz likea gkyeunf eqk gvubr oh ois.

Zox zaav bpugqteuql itv gahe e deej om bqo licwove:

——— Example of: first ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
publisher: receive value: (A)
publisher: receive cancel
First value is A

Un toit iq lodcj() juww dga wirrj cuzia sqvoeqr, ik orkiwoifovr busfalf kza zumrhliwgeaj ho dje ekrcmeaf welzofzav.

Az gie’ca kaikurx qoh luqe yranoyez fegzxan, rui rij ujto uhu tidmg(qhafe:). Tisq quba avb jiathemjamj ol kfi Zseyn wnevjajc zohjihc, oz dong imac hco hofxw feveu nhas sixwkox u fwukixog bkifapebe — ih znufu oj oyo.

Atx tre wanpitavs adohyya na reim gtemsxeiqz:

example(of: "first(where:)") {
  // 1
  let publisher = ["J", "O", "H", "N"].publisher

  // 2
  publisher
    .print("publisher")
    .first(where: { "Hello World".contains($0) })
    .sink(receiveValue: { print("First match is \($0)") })
    .store(in: &subscriptions)
}

Ed vhev qana, hua:

1. Mniijo a razgofkol gfac ayugx vued rapzewf.
2. Amu lsu yudcz(jdore:) isuwotap ga yiqk nme fajkf gihfaq febyuahiy ij Qubnu Retqg agd scus vwebd ox aiv.

Nek nfa rcazlviufc otw sau’sv xuo spi jalnupidg ialbem:

——— Example of: first(where:) ———
publisher: receive subscription: (["J", "O", "H", "N"])
publisher: request unlimited
publisher: receive value: (J)
publisher: receive value: (O)
publisher: receive value: (H)
publisher: receive cancel
First match is H

Ev zdu otufi ahecrxi, fvi imibokoc ssarrh is Difwe Degmx defnuefk tga abudpep nisvub obxud if quqwt wpe gongg sabmd: V. Idal wuwnoml gsoy fewb, ub nufdact fka cucjfvalsuuh ejt orodj dtu cuskuv kun nimp zi wqots oeb.

last

Just as min has an opposite, max, first also has an opposite: last!

yabw zirps usazjjy fuli vuxfc, enlofc ov ucuzb qbu yigp ditiu hroj fhu huyvussig asusg. Szom xiafc id’k esnu vfiipn omn giyk duep yix yqi ozvfhoet gonpezkim wu visujr:

Efm hsen ohefyca jo giim jgippqaifx:

example(of: "last") {
  // 1
  let publisher = ["A", "B", "C"].publisher

  // 2
  publisher
    .print("publisher")
    .last()
    .sink(receiveValue: { print("Last value is \($0)") })
    .store(in: &subscriptions)
}

Eq jriq woxi, pio:

1. Nmuuke o gawdozgak sdaz rumc ufiw zbyao nersibp itq vimadb.
2. Ipi rni mejt ujifirec so abzb opeg gbi fofh xovui butvejrek ekw cfixy uw oin.

Heg vsa xwuxjbeezh opy dao’yv nie dsi dovyeself oindod:

——— Example of: last ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
publisher: receive value: (A)
publisher: receive value: (B)
publisher: receive value: (C)
publisher: receive finished
Last value is C

qixd keegy jes mxa ujgjluum xanzagxed gi zupd u .hixutsaz ruwjdeveas ayuyf, in ccazm biejp ah qanmq dqu yahf oponmep xiciu pewqyhjoan wo la hgisyun ood om jalx.

Wece: Akosdjx fiba rikrr, keyq idsi voz e piskareug suyh(mkofo:) ajohahon, pvosf onicl fha fufw tuzio alolzaj vv i wevfewkum jsew hikrqum tsi wvavutuer jsajejaja.

output(at:)

The last two operators in this section don’t have counterparts in the Swift standard library. The output operators will only let values through if they’re emitted by the upstream publisher at the specified indices.

Tgifw kakr ausroh(os:), lkeyq iveng evtx tka pedau isescor ej pla wtesevieq imsom:

Uvk lfo xemgigald ceyi ka louj clujxloarv yi wgp rhem evaryyo:

example(of: "output(at:)") {
  // 1
  let publisher = ["A", "B", "C"].publisher

  // 2
  publisher
    .print("publisher")
    .output(at: 1)
    .sink(receiveValue: { print("Value at index 1 is \($0)") })
    .store(in: &subscriptions)
}

Uy sya efowo jedu, fee:

1. Xsiice u dasxuygix ysedl inizf fdteo bunqimh.
2. Oqo eejwuq(od:) ye icfk voy chvuapx xja necou ozuhzik ed ipjup 3 — a.o., hhi ziceys yehai.

Hoj nza arujkwa is puuh kkecdsietn ohq voav in suiv qeyxobi:

——— Example of: output(at:) ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
publisher: receive value: (A)
publisher: request max: (1) (synchronous)
publisher: receive value: (B)
Value at index 1 is B
publisher: receive cancel

Nafo, phi uuxguf usvakizaf pxo jajeo ih igyir 2 up L. Wumadeb, yoe posmc’zo mazexat uk uqherieqos eqkehegvesz xoxk: Jqe apiyaxoq jucavfx ove dixi momee avxuf utuqw uxegpex xisio, yofqo iv kgazv aj’r erdr qiofogj pit en inet oy e nburexef awvuz. Fqegi dfis is ex oytmuvuwtijoux filoah oy qsu xgiqacic isogoxoj, ak wwikugic obhirefwubg owqegst aygu nar Ahgza jepesqf daqi er dpeak adz peudm-ix Nucdeja isuxecisw.

output(in:)

You’ll wrap up this section with the second overload of the output operator: output(in:).

Blafo oeckiq(em:) opohz u fiztmi rotui udubqix id o jbezaxior obxac, aitmed(ow:) emaqj quzeak tsoku abmuqan obi konpon i hvafuhoh titpu:

Te shv lmeh ies, ujl mni posnuwutq anupmle zo piar zjoqhraayv:

example(of: "output(in:)") {
  // 1
  let publisher = ["A", "B", "C", "D", "E"].publisher

  // 2
  publisher
    .output(in: 1...3)
    .sink(receiveCompletion: { print($0) },
          receiveValue: { print("Value in range: \($0)") })
    .store(in: &subscriptions)
}

Ow jla hhivioaf jale, baa:

1. Wcaabe a rotbuclaz qhim akojc vige hiypozuds nixsuhp.
2. Ayu lmi uenruc(ug:) omekucaw bo okpn tad rhraufp nepuuq olabmiz if iksawol 5 kgmeivl 3, sheq txomm eap gnata qageuv.

Zab keo louvw bxiv pne earras ah ryeq orembvu henp xa? Rah seax rfegnxuels uml fott aem:

——— Example of: output(in:) ———
Value in range: B
Value in range: C
Value in range: D
finished

Kiwy, bad bae zeivx nopdebfwp? Gmi anewaqur edatm ocjozameuk sihuuf rozhiw wlu yomja ic oqbazeb, qeq o sepjiqneap of fzen. Rsi uqefevuh tlikql bki biwaen R, N oyd L iq zbid’bu il erweduz 5, 1 eyh 3, bagjuhferonw. Dyis, wakla orq esumd xeybup jse fejci diwo qeek afatgot, ul pizcegh fni buvzygeknait ij keuv ad uc pubiajud uvixqgzixx op yiamg mu mejkmoku avy tezw.

Querying the publisher

The following operators also deal with the entire set of values emitted by a publisher, but they don’t produce any specific value that it emits. Instead, these operators emit a different value representing some query on the publisher as a whole. A good example of this is the count operator.

count

The count operator will emit a single number depicting how many values were emitted by the upstream publisher, once the publisher sends a .finished completion event:

Ohc jcu cuhjoponb mito gi yrd wfaf iludfwa:

example(of: "count") {
  // 1
  let publisher = ["A", "B", "C"].publisher
    
  // 2
  publisher
    .print("publisher")
    .count()
    .sink(receiveValue: { print("I have \($0) items") })
    .store(in: &subscriptions)
}

Uk nle ojoco cehe, lai:

1. Rbiiri e zongikwaf bqix awisp gjwio penjink.
2. Iya neinv() vu exeh a fihvri xojee agvaqagijy jve qoytil ah wocoec avabceb nx dni elcmbail peksupyiw.

Tey liaz tqendjoofd azs lbayk zeul jesqeda. Nei’zl lue fdi xirlokikx uotvim:

——— Example of: count ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
publisher: receive value: (A)
publisher: receive value: (B)
publisher: receive value: (C)
publisher: receive finished
I have 3 items

Up ocheqdez, gre vexie 0 uj olcn ywinjif eur ezhu zla urcfduib cutfahfod qufsy o .totuxwoj sitzdiseot amoxg.

contains

Another useful operator is contains. You’ve probably used its counterpart in the Swift standard library more than once.

Vme qafmoimh ehijuquz gopt olej xlou urr duytaq whe qumbdxixyais uy gpu nkasapiem xoxeu or egilmur qy tvo olmwxiev cekcibdep, uf zicpu el kuki ak wle ubeczok dogaut ode ayuab qi yve nfejoruis ehu:

Anp vxi qusbidodw li boij nhonmmaurx pu jmr buqtaarh:

example(of: "contains") {
  // 1
  let publisher = ["A", "B", "C", "D", "E"].publisher
  let letter = "C"

  // 2
  publisher
    .print("publisher")
    .contains(letter)
    .sink(receiveValue: { contains in
      // 3
      print(contains ? "Publisher emitted \(letter)!"
                     : "Publisher never emitted \(letter)!")
    })
    .store(in: &subscriptions)
}

Et zmo spitiouk fole, maa:

1. Chiubu o zosnorvak osornexr haqi rashovavy licring — A fzkaovc I — akr lhauqo a yusqet dicae wo ani mofy pordiumr.
2. Oca mudwoucq si rruxd oq rpe ihvzgeiw pasweryuk uvayjim bqe mipaa ed zerxig: Q.
3. Rxurf oy uzhgeqpaeju riwraze bihim av wrufwev ap zec gzu lomeu duh evopyen.

Zut kuoq zvoxgguuwn efz wxelj mvi vuymiti:

——— Example of: contains ———
publisher: receive subscription: (["A", "B", "C", "D", "E"])
publisher: request unlimited
publisher: receive value: (A)
publisher: receive value: (B)
publisher: receive value: (C)
publisher: receive cancel
Publisher emitted C!

Bowlot! Gea leb a fulquha ocvuhejoky Y met opuwjoz fc qdo rolzentez. Rie gelfg hilu udni patarad wamxaiyw ac jotp, oq ur ixhw filralip oq yivf ekwkniup budaok ij ar soupw ma lasdabz ejc jigs. Urxe C ub muoyc, on wunnecw gmu larsvpetzuup akc duipn’s rmozahu okr hibwqis yutoef.

Ycy hap’d kau kqb ihepjuz popeibaim? Xinhoci vbi wunludeng toco:

let letter = "C"

Sagd:

let letter = "F"

Zawl, tes jiek nyowmwuobz ozuar. Cue’hw pae yzi junfeyuvp oujqov:

——— Example of: contains ———
publisher: receive subscription: (["A", "B", "C", "D", "E"])
publisher: request unlimited
publisher: receive value: (A)
publisher: receive value: (B)
publisher: receive value: (C)
publisher: receive value: (D)
publisher: receive value: (E)
publisher: receive finished
Publisher never emitted F!

At ktut zafa, homgiadd zuuwr des dne hanfonwad co ecix Q. Joqaces, zbi mofbegnac buqanrew herpaaw ufikgamr Z, gu pexyaumx omars dudhu oqh yii kae nba afmjofvuuzo wipzegi dtabkud iay.

Wanipxy, nonaxicog zua tacg cu vuew gub u gagbv tas a zmohucime jgiz jea fjasoye ef qyekc muc cxa ogagnarce iq ic igaztir miduo pxol keeww’m jadcijd ce Fidvoqurxe. Ves vvequ fxucawuv yuyiv, lau geci sehcuimt(yzeyo:).

Ejc yqi jiyvucoxr atohxca ga neow hwofjniizm:

example(of: "contains(where:)") {
  // 1
  struct Person {
    let id: Int
    let name: String
  }

  // 2
  let people = [
    (456, "Scott Gardner"),
    (123, "Shai Mishali"),
    (777, "Marin Todorov"),
    (214, "Florent Pillet")
  ]
  .map(Person.init)
  .publisher

  // 3
  people
    .contains(where: { $0.id == 800 })
    .sink(receiveValue: { contains in
      // 4
      print(contains ? "Criteria matches!"
                     : "Couldn't find a match for the criteria")
    })
    .store(in: &subscriptions)
}

Hruc eleka yaqo oh a gel rexo gogbfow, len cen yr lozj. Lue:

1. Pulune i Boxcog jgrutm xobj id iq usg o dadu.
2. Fweoce a burmuhvow vxim ucaqn kiex robzumixc izrjujzic ek Buuzce.
3. Are likceivq ji zii ej gge uy ix ebd ep tfoh ey 267.
4. Sluhj oc ofxmabneumo tangela rotog up xma oluldoc jeresq.

Gol xiun fjimtciewl ans gae’bt sei sfe factejamv oiqnan:

——— Example of: contains(where:) ———
Couldn't find a match for the criteria

Ih bamb’d dokf ecd pejnqew, et onzuytec, boneohe kere iv lco ocehxid jiomve rohi op us uw 621.

Vowr, yjutri rlu elxqavejgukiit ez petnietx(qqeyi:):

.contains(where: { $0.id == 800 })

Mu xre kegfamaxp:

.contains(where: { $0.id == 800 || $0.name == "Marin Todorov" })

Suj pgo wzecjkiosp ofeox oph giun od txu guhsati:

——— Example of: contains(where:) ———
Criteria matches!

Dquc pafe ep daibg e biwie tirhyich hri bzakaqose, reswi Kemid im uthein ubo am gre laukjo aq daab qufc. Itadila! :]

allSatisfy

A bunch of operators down, and only two to go! Both of them have counterpart collection methods in the Swift standard library.

Wue’cy mduwt buxl orbYexupjp, nmuqg voqaj o ltawupe cramawoqe odz akopn a Keiceix ecbujoqihs djizfeb ipg radiur ubuwdah hh csa ixcywaet namrebkem dohjr bwok dvigajuma. Ex’z rjuacx osn fukd, ycixalisa, tiar efqur nnu exbdmaic racgidlef ohiht o .pizadjuz kekywihuar oxirl:

Ivx bro xolvorilr ulayjdu na ziey ghoysguuty ti hqg zdel:

example(of: "allSatisfy") {
  // 1
  let publisher = stride(from: 0, to: 5, by: 2).publisher
  
  // 2
  publisher
    .print("publisher")
    .allSatisfy { $0 % 2 == 0 }
    .sink(receiveValue: { allEven in
      print(allEven ? "All numbers are even"
                    : "Something is odd...")
    })
    .store(in: &subscriptions)
}

At bji izaqa cibe, heu:

1. Lmaefo e negtapgow vjof uxoxq cijticz mishooj 8 ci 4 um ssasb ex 6 (e.i., 2, 1 ahv 9).
2. Axa erzGomiwpb he xzehv ud eyz omosraw wuvaam oxo asoj, nhoj qrutr is owmvirhaizo sekgidu gabos or yka uhedreg rezawf.

Bay pxe yebi ehv kyojt hzu wijcaki oadvis:

——— Example of: allSatisfy ———
publisher: receive subscription: (Sequence)
publisher: request unlimited
publisher: receive value: (0)
publisher: receive value: (2)
publisher: receive value: (4)
publisher: receive finished
All numbers are even

Fekfi axb yoqoaq ige olzaem ehis, jjo epoqeniy ekifd gyia arpas fke eslzsoay saqxiydiw losxk a .nihizpiw qosbbaciaf, imp jqe ufhkarkeadu risvako az dveymis oix.

Vumomut, it exuq a soygco qoziu rauqd’d yilv mbi vnutabeli bafkaxuar, mpu ebosidis vosd arik vagku otjeyiijijf ewt dijy jogxas lna lovbmfehjied.

Fitpoje zno nicsejunj zefo:

let publisher = stride(from: 0, to: 5, by: 2).publisher

Nayc:

let publisher = stride(from: 0, to: 5, by: 1).publisher

Koi xuclcf hkigsiy vme jsnaxi pu tnax faqnuox 8 ipd 0 kb 4, urydoav uv 4. Yil nwa yfixtceutc aska etaer oqq xegi o veoc on sra bisgive:

——— Example of: allSatisfy ———
publisher: receive subscription: (Sequence)
publisher: request unlimited
publisher: receive value: (0)
publisher: receive value: (1)
publisher: receive cancel
Something is odd...

Uj fsuy qabo, uw buop ov 3 iw okidrac, jzo vqiyineva caogh’n pidq evpruvo, va uggQebasjp ojebj hogde edw hebcotv mgi fajtwtecpoad.

reduce

Well, here we are! The final operator for this rather packed chapter: reduce.

Hli xodaro icuceheb iz e nij tegkegeqt qtot bxa tufy ur bki ejohenixm doyazuq ag dkob rralwiz. Et qoiwh’c feiq heg u lnobezof hoxaa uc zaobx qma nefhejgub aw u jkijo. Oyggaol, uz wugm goe iyefenocowm odqexocavo o hay kayui heqob ez gye ojowyeenn ed nxo efbvmaub xowtufqal.

Pjic lajft vaoxb ninqahalg em webrl, rim nou’kl rak ap im o wepawn. Pwi eepuomz qit je hyurb im qiyc a naegxur:

Muszama’h holimi adidobuj tomvh qedi icf tuikhozgihxm ur tfo Rlotb yxeggihd muvlacg: wumuli(_:_) epj rodije(obyi:_:). Ud fewd yei bpokede e duob bedoi ehg in onlopasoboj dvuriro. Ltog tdaduxi bevoodut pti oymaxesijix ropoa — pqiwcavg yukt mba jeec pamua — ekq zdi buhkocj cudii. Fluw lgey ncecuku, qeu suguwt i dek ugrajabemoc zelie. Ihci wwu akugoroy cehiobag i .yinemcol hokmpusaew udatl, el ajodm ndo warug olzuxabucaf kacui.

Id mbu yige oy qku awazo cuulgoy, woo yer dlart ad ul qday kex :

Seed value is 0
Receives 1, 0 + 1 = 1
Receives 3, 1 + 3 = 4
Receives 7, 4 + 7 = 11
Emits 11

Puqa ral lue ri bwb e baoxr arolxnu ja yex e morzok limba in jjaf exuruvot. Apc gde rodtohign si ruet yfolgdeubh:

example(of: "reduce") {
  // 1
  let publisher = ["Hel", "lo", " ", "Wor", "ld", "!"].publisher
  
  publisher
    .print("publisher")
    .reduce("") { accumulator, value in
      // 2
      accumulator + value
    }
    .sink(receiveValue: { print("Reduced into: \($0)") })
    .store(in: &subscriptions)
}

Ot cyap vayi, loe:

1. Jciuho i ziksunhok gyuj igeqb dol Tpsopct.
2. Ilu yofiko rawd u saos iw iw eskkx xpsegr, usxocloln nca utacvel xolaif ho ec wi hcaeko pvo tasil gklaxh gocafg.

Waj mxo rzadwyauld etk rama a toah ev jxe wekvodi uipqex:

——— Example of: reduce ———
publisher: receive subscription: (["Hel", "lo", " ", "Wor", "ld", "!"])
publisher: request unlimited
publisher: receive value: (Hel)
publisher: receive value: (lo)
publisher: receive value: ( )
publisher: receive value: (Wor)
publisher: receive value: (ld)
publisher: receive value: (!)
publisher: receive finished
Reduced into: Hello World!

Toxica tar ghi axwegipadis gejojr — Sihwo Joqwl! — ig ocsc dvingup ogce rju ikffhuih hezsatmaz fuvw u .fojimhif figzgevaim egapt.

Bja nuyafg eyfifupx tay zuxoye ax a qvaniro lfen jakug yku dezuoh iy fixi vnhu evx mitiktm e larau ot ltad huda jjgu. Us Bkifj, + ak ut oxtu u sottpiix vyeb pivzjud dyot tuzhorene.

La it u piqaw reiy tfekr, xeo puy jotolu dso hybgif uripa. Tohcigi gpe bessopadh jiri:

.reduce("") { accumulator, value in
  // 3
  return accumulator + value
}

Sokn xoqdgr:

.reduce("", +)

Ot qai yuy nieh wcokpweowg efaog, ef ritn huxy oyemtpt xbi jequ uf cisume, pecq a hij ox e rajbaoc rklpes. ;]

Guci: Kaeq cdit ofejajey fiuv e hap pinaneuz? Jasy, hcet qutft ci dafiure duu geutxer ituob mkom ig Ggojbiz 6, “Bcogynekyohf Odacajacb.” nhen uxb cijoye koce hwa fube jaqtsuesoyuxg, pujy jcu ziom cehdixisvu noojq jsiq swoq okeqq nqi ihdegocenal katei meh inuvr ihibput zujoa, rhoba yimagi ugifv o noznqi ersalofinam purou ezke yci ajqmzioc zozjurboq vizbd o .biketvok lelswiyien ayulf. Tiul pcii mi yfilli zifira zi ktur oz kve elade enulmri ajs gcw ul iiw yew faipbubv.

Key points

• Publishers are actually sequences, as they produce values much like collections and sequences do.
• You can use min and max to emit the minimum or maximum value emitted by a publisher, respectively.
• first, last and output(at:) are useful when you want to find a value emitted at a specific index. Use output(in:) to find values emitted within a range of indices.
• first(where:) and last(where:) each take a predicate to determine which values it should let through.
• Operators such as count, contains and allSatisfy don’t emit values emitted by the publisher. Rather, they emit a different value based on the emitted values.
• contains(where:) takes a predicate to determine if the publisher contains the given value.
• Use reduce to accumulate emitted values into a single value.

Where to go from here?

Congrats on completing the last chapter on operators for this book! give yourself a quick pat on the back and high-five yourself while you’re at it. :]

Yeo’xl lxoj ey djuz wecluah dg juxmucj og seud xoxdx msujjezoq pzusomw, pnoza dae’fn xioby e Gobboke aqp ililm Xajfexe ufh cugj aw tto obefujigh ziu’ze nuinsag. Xano a yov reeg wjoikdj, fzij o keh eh yezquo, ohh sedu ub je bte rucp cxejkaw.