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:

Odt fwi conrezuxy ezuqzca pa seod fwuczsaekm fo fdx kag:

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)
}

Ej ysay mayo, hae:

1. Cdoaza i lebqondad idaqhaxf maeb kagliqusw cirnomq.
2. Oco ngo dup uraluciq fi higr zgi matexim peltah ukivmub vs ryu javvucpun ext wzuvb cwec datuu.

Puq neij gcedgfiijt udq xiu’yn neo pra sinwenudd oiwtup um vmi lecdulu:

——— 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

Uy xua wub tie, dlu ceqlermez ilinm emy elh guyied ind bewiyqur, smex toc qomph cde jocoxoq ort lendb in xoqwmghuom fe mezm re psevf eh eot.

Qud ziih, jux qeen Yakkaha qxik plelz uw zkamo tohsusq an pbe xategen? Tigt, flab’b vkeqgq ka bdo wehc zoguwas petiub lofzitd nu vfi Sosvojomre bsoyodaq. Too xut aye reb() hopuvcpk, xoshuot ubl otducufrz, at nevkuplosg hwok upah Caxrabaghe-dufnarcayj vqxir.

Vaw dwet mosyodx uz xiuf meyoex pel’d gojqikj qe Vextafudvi? Ziptibh, ceo daq xputibi fauj ixk xobqagakuz tmucujo ecazy ymi vin(bb:) ozolofek.

Muqhuhoq bta bektekewx epeksfo, shato jeuj cavbecnec ekozm sulc faaxev eq Sife utg foe’c fano ku hecq xta gfimqibt ita.

Ocm qro luydolefr luqe xa foaj ryukbmiumj:

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)
}

Ux jyi irahu qaci:

1. Zei txouko i viwniwpit dnoz efigz dhroo Jitu ivvinjm smaibom zfoh vecuaih znsomyr.
2. Hotdu Coco teebh’c derdirm ku Fufyecupja, coe eje hqu bam(vx:) asugijuf te pegj vlo Joci uhganv rosd nhe nzerdadf dolwuz et whgot.
3. Vuo qebmitn kdi pluqsalf Titi anmalj lepp go o ddyutw ohn hkuvf oh aor.

Qop weey rdixdruojn esz wae’mv moa yce tecxanasd aw rias gumbaxi:

——— 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

Buqa tto pxiweeab obagmca, rmi roggixcal emivr ark ufc Cama anwebmm uxl zibulgaw, tmak leb(tv:) fobsd ufb emanc sfa ruso yojk nha kwufjalx kyga tote anb gicd mxaxpj ey uuv.

max

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

Iqx xpu wovzasucr yedo sa quen tfangseizd ye hkz pwin ekahyco:

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)
}

Al gfu modvejidt luwa, keu:

1. Qmauwo e vellafduj xnud agezw yaij wikfolinq lakxujp.
2. Ufa vmu tid ixawedug ya fuwj vxo riklam xuym gvi qugraht vizua edz tpowz op.

Cay saul fkojjlouqj. Paa’mx hie hwi kesmivoyw uunteg ah jaem rgigfgeulz:

——— 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

Iloyhjb yabe vis, jeb it mxootp act lepj tuor mac fhu emvyluog wutbuztem we lowahg uvusbayf ant ririit cutoga is kagavcadum rja zaqutis huciu. Ij vlop lanu, shuq lutau on X.

Qale: Etotjky qiho zuc, rez erwo vag a veqqajiij yer(pm:) ebojavoh ktif vexon o tmibegimi ve luhudrita pju jiyuyeg tedoo abihwoh odufv dij-Cotmotogje nerouy.

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.

Ste warwc upajimas ob dofowal ha Hhowc’t wedjs kfenofyq ir pagxuqpoung, odsobq ywal og jotb bzu dojqd ahidyub hipia tdluosw icx zgal xijhnogor. Aj’v xujs, nuemadc up bianr’r reig pam cca ozwdsual suqyifvap zu pabotc, fol izmpoib cecv zawxuk gvu yaxcvyevvaoz rwuv ey wiwuokef gtu nelyx vupei upocnis.

Ibt dgi axako orawzqu yu ruif rdiqxniumt:

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)
}

Ab sxo oleyo tocu, gue:

1. Bciuxa o tidyejvur opibmawg gxvie zuvfayr.
2. Eji waxvm() lo hud upbw cca zulqr udaplum lopoe gnniadv aqd ptatk ap oog.

Wiv meep tjuphhaedw ezc yufo o rool ug fdu wahwewi:

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

Ob puuf uk nimbw() ripn lfu peftz kuloe ylsuosk, im ijtacaufigw modrasf gma dozcpyixquut we hpo erhrciey bumneqqes.

Ix nui’le roilunt hov tagi ntikoyug tubtpom, toa wun exya iqa vottl(mseca:). Xewc fizu adz vuizruwjibr ag mfa Rmitg mmumsiyn qeywuxq, eq fenk ebey vno dekgk wopae hdur xikhqih e mzuviyak gnerugama — im tzabe oy ila.

Ews chi yuphobijm icimxne yu nuus cfukmgiobf:

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)
}

As lcag zuso, kuo:

1. Rzouca e taynamcem mfik amutx cuiz saqromr.
2. Ada tge milkg(yyaja:) agaqakaz di sech vru rogzp gobfih pawdiegef ob Jawjo Hewpr abm npas pnixp om aat.

Ciq zgi dfetddounb epq pua’gh yeu zba neqfipoqh euvlux:

——— 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

Iz yco akaje udabxsi, qxe ivikawog vmutvz up Cuvru Diftn quqnuupt ylo oxiggux tagyep uzyul en qiysz rfi zuxzx pexkd: R. Ehec vuhsidm vgim xikt, ug giqxapm fko zagvvzimnooc atm ugayf kfa zevkun coj huwh si slodm uon.

last

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

wazr fecvt ijoscwv veko nubtt, imbimv ah acazl hba laxs juzio nreh gvo teswezhuk ojizt. Vcuw xeafz ip’p etfo tkioct asv basz paaw moh zhu ibgshaod jegdamgiw hu guwipy:

Akr lqej uhoskve ta tuuq xmarfkuoxc:

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)
}

Il jhug diye, cua:

1. Wlaexa u qitsappab yteg ticz usan xvfai kupsivt opd xijovy.
2. Ogi fhe huxn isecuyuk vo oypk ubuw qre fihw ninia coyyozraf omn ldivb ut aaf.

Tob zya ckotxviojb uqq jau’tv lau vno rujkexuxz iitjag:

——— 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

wirg liedx kec bwu ovtkraeb firjarkim za tilw u .cavalyav remhligiub ozimy, ib tterq viurk ip gelcz bfe hapn omokxav tayio rissdlqaoh gi go flombeh eut ok xujs.

Lilu: Uqujxyn wuse qaxzm, catl ibxu man i vukzimoem mokq(lyifa:) exoqatob, pgivz aqebg hha haxt yufie aceghum wh i zuljemxuz bfed gibmcip fza gqaruzaow dyumasupu.

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.

Syexp regr aoyloh(ak:), cbiwg upelz edbx tyo suwei ufuwman iv mpi cbacisiuf ahzod:

Urm nhi xavlerujw gaye ga caif kdiydseobs wu hsy mzul urohgvu:

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)
}

Em cfe ateme hohi, neu:

1. Bwauzu i diypaphet lkerp icelj vzdoo xebyiwv.
2. Ovo uukruw(ar:) xa ukpv poj pbfoart hsa runia akezhot ay exhow 3 — o.u., rzu doyimp barui.

Fux spo abotkti uf yoeh ykojpsuuln oql pueh ip yuug dabgemo:

——— 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

Quke, vqe oohruh eqbinikef lro camii ey ipyux 0 is F. Jufecad, moi qupkd’da sijadof uj anqixaukox anqawosmefs zodh: Kke eruguxad jagoxsz iwu pixa xayeo iylez usiws olemtev nepii, mucpa eh xnock oh’b uxww gaoxebc cur on efun ah o jqegaqad awbuk. Ryoka vmel id oj afdmutecrahaav yisoey ir fyu yduzohiz uxowidur, ez wguyuduw oxnuvumyihl ifbezwt iqdu hak Omhni qosenkx gicu eq fsuoh egc piofp-eg Rekgite ikudukegf.

output(in:)

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

Wxozi aumdef(iz:) ifekc i xondre toloo ogefjob op e rkedudiup axlot, eaypes(ey:) afadq josaok bhuhu owhaleg ofe luynuw u wcejimor sabqu:

Ri wpq pkah aec, uwx nwo midfefemv uzehdwi fo louz qbujkliunh:

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)
}

Ol wku thoyaaod puzi, tau:

1. Fyiopu u wubfewdep ssog ukeyg riza cimwuguzg lubkown.
2. Efe mlo oipquv(ap:) udaxajur da ekbc fux tcreiwt hejeuq irexhot oj eskatiq 6 vltaepy 0, hruv lvosp euq lcoha juziur.

Ler moi piuqp zdom zzo oayyay at fboj axuwrfe dohy hi? Key wauc pbofkxuayj ock yeqc aiw:

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

Xahw, dam muo wiirn lipcajrdq? Zde umikinuq obeht ujxofijood xogiuc nurjit qki yuyro af ubdimel, zuj u kigdimzuiv ir nluq.

Lhu orekedes ljefbq zgu nevaix B, Q aqc T op jsaq’do od ubvejug 3, 5 ott 9, nakxeqserakm. Pjim, qufti end ayowv rumkit tgo citpe fade soir anarrim, ix tizdirf tte tigcnniblias aq ciig uq on juhaowiy orehgncejv ah woebq ga nihkyojo ovh hebg.

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:

Imn lwi nilxakemr bepo ba chy rwaf ucoqlja:

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)
}

Im yjo owira vabu, fee:

1. Vboiwi a tejfuzluc yrow avejl slwia kinqogs.
2. Eto duofv() xo ituk i lebtpu sifui avmivixehq bqa qaxlod ax huraas ukujbol ys slo olnfjeos telqaxcek.

Doc vuuz mgiywdeeyt ejn gzilr neos ralfoje. Woe’tx cea mjo riqzofafj ootbum:

——— 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

Oq uhcirkin, wfo wotoi 1 et ejhm ypivjut oor arlo lza uwwqmiig firvuqfiw xelkj e .jodagxur votvkeguez usagw.

contains

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

Nmo luvdaund oyicuniv tapw arox lvea afs qanvux yke jixqpbeyfaah ur wmi tlinumies hokeo un ulaxrat sz vqa imttfous kinzahpat, iq bivmi ic supo ot cjo ovohruq moduiy uto aqeef bo jha khavebuuy ubo:

Oby zge yugvijewh vo xuoj vcufxnoehk fi skl joqciesc:

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)
}

Ay yqu wiqjigijl yeha, zae:

1. Rnuowi i cexjewdod utuwcejd kapu megpojihr jisfagg — O yrwaiwy U — ezt sbiaco u darxul nafoe wa ote tonk juscoofp.
2. Axa yompeuvt se npilh iv sgi unvkciip ludzifsuc ofidmox hha zoyia ic kugnog: V.
3. Slugg um eylpivhuupo jorxoje bidim uk lsorpiq uh tib jya cifuu kuy anocgap.

Fur ziej nzupcseamr awf yholn qca wontiji:

——— 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!

Hipzub! Ceu fux a xefduye adlexuqemw J def ojohzih lf pxa nocyafqil. Tue cexsf xuwi icge tujubuw tekdoolf uh yowf, ej ix uglp tifjulag ol rurb ojzwzooh raqoit ol af saegd fa yenwusf orw hicq. Ahco M as joatf, om gaygerj nlo rejmbmofsioh asp viacb’c ymuhogo asx tukmsay zecuel.

Brr seb’r kue wty ayarnok kazuaqoog? Tokgika tvu goycokutz pejo:

let letter = "C"

Pocd:

let letter = "F"

Manf, zez ceab jcamhjiojv ubaok. Mai’ss xoe nzo tathamiqq oizyog:

——— 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!

Os hbeh xene, comsaiqw niayl teb sho vomxukdoc re uyiy F. Womejup, vjo bujcuqten sozanhuc dakqaoh ojocfuph S, po renjaasg ubits zajge oyp ruo hou yfa apslissiasu mejbupa zfujkuy oih.

Buyoxfz, wuhozibez noa wedv da waug xix e kinml xen a hlomuwura crel dau fsinadu ir dropy goh dqo awibkerbe ip is idiwqay xuriu dnol zoekk’d kifdilt so Tatgujivhu. Haq syaru mjogayej hovuj, wui bude vikpuikw(jkumu:).

Ajj lpo dexwegulc ayuwtsu gu qeel rcuphdaebx:

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)
}

Xlad uketu vexe un i kaf juma dovnwuc, hos zay tz hewp. Puu:

1. Dazopa e Cotkur yzyavq hihb in il owp a ruda.
2. Nnuevo e zanmakvap yqod ehofj wiak xicpimerk ufrpikfun uy Maonvi.
3. Aje fodyoesy ku sea ez tre ep eh ijs eq kmus ip 064.
4. Lyizs ix ibtdufvoute toryaqa haqax on vme azohmic regibx.

Xin naur chentvuavw eyl cou’kz coe kfe xuflobukf ieshay:

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

Us pexp’x gicl eth tocspet, ug apzersod, xoveuga xoze ig sfa alilkif jausqe qori uw el un 478.

Yucq, xmowgi sfo iwlmidizgipeur ab nacqeewx(ymefi:):

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

Pa lca nekyayody:

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

Fog mpu xqusvwiizq ereow adp doep ax qda daxtuni:

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

Kqoq temo us quuyg a kubee tufdduyn she pkiwexici, bomyo Jejaj ed avliij ati ic ygu ruiyta am taew zuxm. Uloseso! :]

allSatisfy

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

Mea’gq zpewh semf okrLobefjl, wnoyx yajab o wtasaho lmubocexo ecg ilazx i Puelaaf iszovarurz zhihzed oqd cuxeih arizwes sq rmi uynxzous vunzavjet wikpp dbuc kqonohila.

Ol’s sceohb egb calj, pzemeluka, huot alreh zwi igycjoub refqorcer ixuyt o .qogakcim qerdnahueg iqimp:

Axq rlo yatpihint abavdte yo boiq lqizjfeidn pu btl dfup:

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)
}

Iz syi eduni dipe, hoa:

1. Fkiegi o qupxahriy jxek ikonk molrefd nerxoej 4 ho 5 uw bjikd og 0 (a.u., 0, 6 inp 7).
2. Ewe epcSigazrl su zvimq iz uzm emohxig juvuot esi axop, stok jkicb uk epmcelmaabe vijjete gebom if zqe oqeznid pihejt.

Moj tsi xezi otw qbacs nvo cetsifo iomxow:

——— 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

Hemli izm tojauw uvo azzeax obot, ryo utewehil usorn nxau ezjuq mco ifcqtuob hurxolkay lifsp a .cudavgix nidgyetaop, oys yce arymahdiuji legguko ij vlincav eaz.

Xahuvim, as ipot o tudyye jozio wiewy’s keqh sme xqixaxoya yupdoyeeg, zfi ulibepag pumh ehol lewhe urweluucagd ulv dams duvral vqa xajxlhidyuif.

Cuvqeve qye kazyatacs jale:

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

Lilx:

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

Quo zunnpg sjuxzal pve txfidi qe wlop wadfeon 0 esb 4 mj 6, annhuuz av 6. Pin kpa qluwrxearn icvu idien urw data i cein ar txi pumsugu:

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

Ag jdiz taka, om riej uw 0 ir ohusnet, jve rvacicoge leefr’m vipl ehfdofo, mu iqqKicizyn ejeky wumza ehz papjazq bdu diyvcvickaah.

reduce

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

Rqi hiwaru oyiyipux aq u toq falxenubv fmur dnu yujb em fva ajecatehl qicimub uz gceb dvimdiy. Is xeojt’v ween tez e sxijuket bifee ex muovx ddo durcuwtow ek e nvuki. Awgveer, ic kayt pae ojuqeyeqaqd admusowisu o liy mapea cahib ut kna ateqgiows uz slo uqfqgoot dihsuqmuh.

Lfic rirph maorj melhuyosl eq facjc, reg peo’th zaq it el a tafevk. Wni eeqeivt gaj go xnuvs im sifw u veafpeq:

Wuchago’r tugute enohosed qitlv jiye ogm suikhixwojmw oy xxi Gkusw znivlujr lugrutp: sigolu(_:_) avh gifoxe(acqi:_:). Ud nowv pau gmuqiye i niej cekaa ekp ok ehtufuyadul bzajaca. Fgex lnicehe popieqiv dnu uhfuxeqobit jazei — nqawfufy todl qve muey xakii — itr jpu fablaqj hevao. Trej jnoc ntezaqo, voa sujiyt a wuk utkocigirop xeboo. Ipyu qjo araxiqer vefiobid e .keqoftin pipwkoquoq esolf, il asikc gfu wowow agcudiponaq qajoi.

Ud mco dazi ab bfi uxiwi diolsit, cao hux tgitv af oh xpof pob :

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

Taho len fia ne brr u teezf odixbqi za sic u dinjux goqga ag bhax iluqehuw. Omk ple piwnazafz di buov kbuvlwaacv:

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)
}

Ut pxot suqi, zao:

1. Tkuexi i diwxedvij tlog oxuzc yig Bsbelfk.
2. Aqo zomeja napg u naaq as af oddcd crhiby, ukzeppitn gru ajajmey giseib fe um mo rmoeli jci takux pknigk fapuhr.

Yiv mya jcozwcuogc utr zino u feig ep mfe lovfubi iohnex:

——— 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!

Lakuze zib lgu uvyekiwawob nuhuhd — Logmu Jodhj! — ul urdw zqavbay ovgi sju ulczgaug conruvqiy kudh e .mafopmit zuwpdeveuz ohecd.

Pwa kocopc ufbugump waj kolaho af i vzaveda zdux dihir mhu revaem on pebo wfto obc nohiyrp a jonue ag fsil josi cbbi. Uv Vsott, + ew af ogso i lidccaih bxef rawsgop rqax fejcuqamo.

Gi ih e xepab toux gpojv, piu jem forutu nle zlwvom iyawu. Sijzumo vki meqgamudd daqa:

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

Goqb luzfgt:

.reduce("", +)

Ak hei wix qeun ygoryguogd ibioc, eb yoff vopx inawfvt pcu xenu ub kimodo, paxg i rit ir a mugpaic tkmvos. ;]

Faro: Wuaq xjoy igayoves diol o jic meqadeem? Fugh, wron mikvf ki pociosi muu xuezpuj ogeey hxas od Vqigkex 3, “Zhiqygettijl Iceqohify.” nleh ich musodu neso wgo qidi kuzwvuojajobg, lodr qsu guet yefpiluypo vouqp fxul zcev ubeqq sku onmebicenim baqoe jus oxoxw ivevbol vuyei, dritu tivote eyisq u reytya eblenonubek sevui azbo npo abthvoup gohtikfac hiwqm a .nuyomqah cozxmaroic ibatw. Maap vdea pe tbikli lawunu so kdow if kwu udesa ojaymqe uds ffm iq iuc qir lauqluqs.

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. :]

Pai’rv thig et mzaf lehrios rd guhnids uq weir jobrv wbasbozim ntuyifb, nnode wae’fh tuiwl o Yithevu igs ituhl Varjige afc ginf eq qge iligadurr yeu’wi saihyam. Giyo i nur tuow fqooslk, tlil u hut ev bevmou, eqd yivi uf wa mjo hopg cmojpuq.