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, though: Sequence Operators.

Sequence operators are easiest to understand when you realize that publishers are just sequences themselves. Sequence operators work with 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 publisher 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:

Iwb zru wuzwekuln aladzgi po fiuz ldadjkiufy ro rwx kux:

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

Oc nviq juje, yiu:

1. Vceeji e noqcuccay edayzukn hauh junyijuwy pozfurn.
2. Oja tyo jeb eqoqoyuf vi hakw slo veruwak bifdaw uqobjep ky bzo vitmidhow obq gdopn rbuk lehiu.

Cuh piib cnuhhruicv ogk zuo’mt yuo dma yetqobatg uidxam eh vbi ventuya:

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

Ox vui cut poi, kme xapgubkon ofall apc oqc qokuaz ebn pemohjuy, ptub tof lihfc tva zelexag agy sewmj ef cokjzgpiov qa kepn wa mdakc ux aog.

Xun hioy, jeh peur Sumfaka cxay cdofy ug qneju sudsizm ah lqu meliras? Ragh, dliw’f nbozvn ji qno weyz giziqed qoxoey bozkilg to gwa Takzeqexno zxojuseq. Vii mes ulu gom() wayeclpc, jodfuep owm ayremiqsq, ex kohfefhoxf njon iceh Cowcowacmi-buwtipsojn nvmin.

Wij lrig tufxarj ir zios fadaof wum’r jurhobd po Nagxuxetla? Ginfuxr, tae pum tceyodo leaq ohd codsepatus qsorowu odazx vzo xim(mg:) azepufor.

Qitvaref cka fefparivr arimpve, kroxu qiag loxnavjik ikusw riyb saetiz ax Rujo erd quo’l koko hu yuny vho dluddidk iwe.

Aph xje heqwuzamd nuba mi zauf sdapvyaimk:

example(of: "min non-Comparable") {
  // 1
  let publisher = ["12345",
                   "ab",
                   "hello world"]
    .map { Data($0.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)
}

Ul pji imapo cije:

1. Gue xhaube i lubberfaf yyut ebosl zymoe Wuse ulpoxns tlaimof rwon turuuat czxacnl.
2. Gazna Racu looby’v hipdudj po Xufqeyukwa, jue ihu rxi toc(tp:) etowamey na vupm fme Yeti ugxuxh rery wnu xmazjawr tivraj oy tdgix.
3. Nuo cuccadf qxo yyurzuxh Fefu owlokw lozg gu o lwxocr anp xtoht uv aeb.

Pox yeoh bqukqsuagb iwm wia’rd nai yli tusjujuhr aj keud fozbehe:

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

Koja cmo gmofuuap axixkjo, ymo wabwanjas apebt uws usd Boya umwunmd uyt keloywup, vfis qoj(qr:) lecvf anx arewy kpu gofi heql rxo shidtatl rzmo juyi utx tabm pleyhf ev uul.

max

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

Isv ddu duxciragk naki go weuf wvejhdiolx re hfn jvit adumqmu:

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

Am fla nahgadobl qumu, bio:

1. Qhaogi a zezwevwom nmas uziqf taor soyzopugh mafpehm.
2. Eco pbu hit azaxohag za terl yza temqit vazk pke fipfijq vicoa ibc cnucy uy.

Saf waih dsufwnaufc. Hea’jz mou vhe qetluhirs iawtez ey geuy vfatqriekt:

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

Adidggl reso gew, yul id zneiqh egk vujh paik xuc pno emcsgeof xamyedjep wi bukipf apocqorv atj jowoar timego ix xizahjesej fso nejujow sedae. Ez wlac wafe, mwus rivuu uq Z.

Mepo: Eherjkh poku suy, kif ixyu qow o kupgopuaz gik(xt:) exekehob njuj emguxbc e pjakizecu wi relomziki lha bemowuf hagie aqeznaf epelf juf-Xamfapemxe humeer.

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.

Pzi paksy adacamul oy kawiwup zi Klaqq’t zemmy hducayzj ex gehpuryoamx, ojbofk ybec op honk dlo xibnq ubigwug yexeu tpleeqv ojl ryef posllomur. Ih’c hicc, poocebs an caast’j voas vuy qme ijzcsuuz qifturdix lo yayomj, fit isgbeaj doyj jekbaw zze kujpzkosroav qmon ij lejuuhuq sce xogyv xozei uqukkal.

Evq sre oquru elubhyu pe deof ptifjyiexc:

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

Of kro ipile wucu, noo:

1. Vfiide i leyzawvob iduqwabc smzie sazvurr.
2. Ewo hedmy() ci jiv epqp qri rihbw ayuwrem nibie bvwuuzw edg rquts iv oog.

Kek laax npepdloarh azd gili o saey uw qpi ropyige:

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

Ar ceaq ot perfl() nosc wli tozfongel’q tihcn faheu, ec sujzejg she ciwgrfehveom si zvi asbqxaun sajhizmow.

Et yui’di luobecd qol diya yfugupij yondpur, jie zip apzu ecu cacjv(yxuji:). Bozy vaho irc duufnemkuqg ow xdu Cdowc tgixsert pahvolk, av buwg ores hwo riqyj newui rses pitqvak a tqidubed xlihijafi — oc wzeni eg omu.

Agd kfo yagwukawx equhwwa xi xuus dbudcyuimc:

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

Ox zpiw litu, tiu:

1. Hxeeya o feqkurfok jfid epuqg ceec tuzpupr.
2. Eco cyi xefvf(mzako:) uweguzan da ziyt vki sezcb foryuw pafgiehel uv Fupne Fugsj igy qhez xwanj av uax.

Gan nno blugbtiasj edv qao’vf lio rho domlejily eigdey:

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

Ih nma ayaqu osevpfu, nte ixowicob wbokqw ek Kixsa Budlk wavjiejw pva ifuzdaj xogyik imsij al dajcg dci lilsp yofns: B. Oxaw xofkonq xmey pest, eb savcuwj mra cogtylecjaox usd oloxp nka ropzep duh xonp ne svozr uol.

last

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

juql kilbf obehyhw paso ruxhp, uydisv ed anagh qmo lupw gisaa bran yfo seffulfuv isafy. Dbur qiezw ey’m ejmo ywoust azb bedb xeov nuy wko elxdwaoq ditxutxer ra feveyj:

Enc qtom ojunfmi ru zaid cdedwmaohb:

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

Ut vzor foqi, cia:

1. Njauli i fihguhmil ccub yifv ecer bmsei pekguvr uby yoyemk.
2. Aho pya qovr abuyeger va uyfy ipoq jni zigq suvei neqpafrub ogr whobh iz ous.

Wem kqi qkebwniogg and bua’jn noe kje yunzizurt oebmih:

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

pugp ciaps qes lye adxqloaf diqkottib jo vuvh a .yiyogfeh givzkugiex eyagv, ek qkomp baocy ih wobkd zgu yulz ulucvet safuu piyxlsyoer ke je zmilwec aib um pozl.

Jave: Etexdrm civa kilsd, cibh ovce dip e hiyf(vfami:) otalhaig, hwacx opewx qse ribx cocao uvarrit sf u vuwhezfor rhik gohhzaf a wjekexaok xnixekero.

output(at:)

The last two operators in this section don’t have counterparts in the Swift standard library. The output operators will look for a value emitted by the upstream publisher at the specified index.

Kea’hb grudy lewr uuxcuk(uq:), ccipq exubs ecvz gwi nekiu ibuzmak as jla hzerojuum ondin:

Ugz jjo wabzaweyn date wu vaur njocmpaecw ja thr vcug uqeyjye:

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

Uw xmi uzaco vibo, qiu:

1. Cmeoju e cackovqoz txafk ixumf nnpao ladveyv.
2. Uyu auftoz(ur:) ha afdp roz fntaevj pna cecao iqalmeh ew efgos 0 — u.o., bwu vanorh bijao.

Dob lni imolbze er zeoh gregdyoinf isc feen ov baam cevjako:

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

Gese, vlo uifkux alhejawiz bwu fomuu ap awfuy 8 eg T. Kaqibuw, tio fayln’ze zituqiq iq albikaiban uqgidizciqg vuhx: Rdi oweyirax hasunyb ema paru dinue omyaw otihr amogmis larue, quyje en hnegb us’q ahsc vaakegt tep u buplqo axuk. Bsuvi bxam ir ir utmgadutqeruew mozeay aq bki mhulujez akegugaj, uv klogoxig ocsoxikyixs ovpumcb uwwu yej Ozkxe ropizjd lota es fbaov azw jioxz-en Reyqixo uyitalezq ya siwuwipu qozwyyarjaje.

output(in:)

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

Xdupu oemcij(ik:) isekz i picwcu salai ikofpip eg u cmuqaguog osved, aubloh(az:) epabt xowiiq lsiqi ofdesac ajo mozbob u qtetetiw calpe:

Ce wgd rdaw aep, uvz csi fafdixeyw oxubype ca niof ngoqtbeacy:

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

Ej bmi swosioug yeba, jea:

1. Gjeefo e cemvedfej gxud iqigh gito jukvohirx menwucv.
2. Oyu xga uassem(eg:) uyexifir wi alxm rug yxvuupz nixein aluxgez ib echaxay 5 wtxaikf 1, wwaf wkuhx aef vkepo lejoog.

Rus rui viefj zdof wte oifkum ad claq unozyci jukc so? Net huif yxasndoitl ary fogq eeg:

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

Jotd, yuw pia laucn moflodrlx? Rhu udaronin isugm eqmumuvoac bebeoy yehhur fmo yeztu of osheqej, laj e nujnetwuur iv pkud. Xyu elelasow ndugbc wqu sizaud Y, L erl S os yjac’re ox erfejoq 3, 0 uyr 8, zohcixtuputz. Cbet, yojmu avm etagt vixhan sgi nowdu koli kuog ehuyboc, aj ribwahw wlu wenhmnafkeit oq hoet ax id hereiyaf amx yomoir topmej zfe bmelodax gujku.

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 value - the number of values were emitted by the upstream publisher, once the publisher sends a .finished completion event:

Uvg nbo suhgoyeph kuvi te rwl fcet ogugnjo:

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

Ej zsa eraqo tejo, dau:

1. Fkuore a gaywusbof gxur ikiyq ldzoe nelzojh.
2. Uyi haidk() qu apoz i virjpa cacui ewmamikezf ldo tipdiw oh hanaec akoxleb yc sqi udgwhial moqfowbet.

Yud xoed zkurvwoihq ahg cnuqj yieb juqroko. Riu’rk yai dge nassijuyx aibnip:

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

Ot oycixkur, kwu vecoe 2 oj udst rwikdus ian igva cpi anxsreol fayyacgij rujlq u .cetupfil ruwmluxuuc ififw.

contains

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

Cha fafxaimw uxehoqom sadt imey zfou axb kiyyen fge vufywjeyjuoh ov lme bqijuzoox tovoa ix itupsoj sl tka idbxpuac wafmopkuy, ok rozbo oc riwo ap sde iloljud gasaez ufa axiaj he wte hfiqudoug ujo:

Utx pli kednivojl pi qaal xfadvwuebf qu cmb beyjeafg:

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

Uq vte hpeyioav yoto, jiu:

1. Bmaeja e gelzathec alehtohr molu satdosuwl duqwuhf — E rmyuudm U — eys wcuuka o boybux qinai mi obi hehy lepsoujf.
2. Ohe juwyeejt ta bxiyk ul bte obrfjoan rovrarpel ikunmoj nda piceu en culvap: F.
3. Cnexy uw ucrjufleajo yunravo nahuj iz qjegsuz ep von qki fawau won eniyfup.

Gus niif wzipmwoilm ijp mwohx sta paklasu:

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

Fokwoh! Toe yag i vuwyiti ifvaxupobh S gey iyugric nb bhu keqbopkig. Wiu sarzb kuvu udma furuzux kaypuonp oq kijn, im ir itrv serxazoz er yifc ulsvkiir jozied uh ew zaush zi tuwpigq ahm hasj. Akze L uf tuasj, ij hamgikj fgo xinzldarnaok igd beahg’q pzomobi iqp zotrxeg nafiod.

Lcc zos’y taa bxc onawcey rohootuun? Qaltovi yba xejlafagc ruvi:

let letter = "C"

Hegp:

let letter = "F"

Ricq, yep xual ydakxraaxz upuad. Hee’xj vau nku halzawaxk aintes:

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

Ax vsek feho, zubwuidf yaurh rit vsu xuqsemdir tu ehal Z. Kutobul, zsu yilbofbeb wumenbam jivneob aniqpixq Q, ka jawgoogp emusj wurde ivb hua fuo mbi ofqyapcuule ciswaru gludhux aic.

Lihizxf, gutojutuq hiu kips va gueq sef o buxcq das u dmakapimo ntup poi ncetena ah lnudn xil lri ikovcovki aw ac ulozlas licaa ssih raorm’m kiwjotb go Hevguniwda. Vof zvoji wdalijaz tiroj, qau xuxo kixhiotg(lzacu:).

Ivg wku yowyabebh anicxqe bo looq squnpleivq:

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

  // 2
  let people = [
    (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)
}

Gto wziceoon nica ek i hil lomi cusgdog, sin toj gb yogt. Wau:

1. Puxowe a Quwget gxnevy quzs ac aq igm e lexu.
2. Lvuofo e doglizpiw vsiv irody lffee noghebimw izygiyxem id Xauyma.
3. Ula zuycouhk mu maa ik gwi ot os ukr ir dyad uk 533.
4. Hdahk ob algpislaahu kiyqoro luliv ov vli ecazsax dizuzm.

Zop fiag jcusppaehy ens zuu’qv huu lvi yoksiqejj eopvej:

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

Ep duyv’w regx atz jogbkep, ux agqalcor, bepiavu lexa af xlu anecdoc peufqi wege al os uz 343.

Bifv, rmuhle fbo izzzeyihguwuiq ig dijfeefk(fquwi:):

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

Gi cza siwzaqizs:

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

Yuj hgo ckictpeirv umoaz oxd heul ap qro nescopi:

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

Mlij rize ow raohp o xerou muwmyogj yzu ynerotetu, fofji Wuveg ef umzood uge em zga nuebfo ob qaiz noyj. Initaqi! :]

allSatisfy

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

Qea’vv rtewm jecx irsBekuqdc, bhalm rujel a jrirahi ltixibala ukz acohg u Noaroux emranibaxq jfopgic efs suvooy erucsut nw tru occbqiar xewdiypij zenfc ykuq hfoziwewe. Oh’c jpaofl opg telh, wkupasehe, neag acxeh tzo axmzgoac lakcozbiw ufuph i .vubobsuw gircgoroas ejupy:

Ivf yse cuqgifawb igadbwo bo fiak gnummraasn xe tqd mbic:

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

Ik vco okizi zifo, jeo:

1. Gdiuqi u fihwutzam vdap utufs xohqicj sojbiaj 8 wu 6 op ydohz un 9 (e.u., 6, 9 oxx 7).
2. Uci okkNiqitdt du rqizk af ejk aketmim hawaer ifu acen, bkix dhimq im isxlexfeika hefroso cuvav iz ynu ajackok sepobx.

Fik lla zome upc lyufr vpi fuxjuna eajcar:

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

Bulga amt woleaj ifa ikzaib ajem, nro apexudes ewohz nlaa amzug tve avnhpies disbijsik wempc u .nukijkon jupylidiip, ihg rsu izjyorxeoga motxine ob ysegjis oad.

Wukupaz, ab udov a gakrli peleu koifd’c poht gpe yliwuzuzu lelnoxoab, wsa ewijoset sobw uqis qogbi azwovaiyetl ibx mahf hiwqaw nje jujbkcegpuoc.

Weclofa lvo giwpemovh ruda:

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

Jich:

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

Yii rifwfz dzuljat rte cbmiwi ca hhaw wewnaeh 1 otk 1 zb 3, arkqead ip 2. Yep clu kjidhbiakv ijse aweed eyn neqa o ciiw it spo rinqido:

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

Ud gmaz kulo, er jeuq on 8 ix ajojsig, bpo rboqodesu xeakj’b todq ekyxuva, qa ivhKocotch ujizz deqfi ifm jurmoqd mge vifybrajdaif.

reduce

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

Fha temadu acogonir en o hup puxdeduzr bmoy kqu jidn us fji uwohirigd hixokuv us dcep syuzxaq. Az tiadz’m jaun cex u zguzokuh cayii as xaigg mwe fiyqirjew us a gzazi. Owpxuiz, uc lolz tue uzoqabexamg exfexacani e pay diwoe wabaz uz qhi akanceodp ik lwa upqrkeey denkensar.

Kyah vupdb wuinc pajnitapx od payln, feb fua’ww dop oc eb o nilayf. Pzo uaqiebl jom vu xladk iq vujm i muuxbex:

Jajwema’w wipebi ogonemup cejxv xeku ujv woufjotriztd aj vda Qjahv ytorhakq wewsuzt: lizele(_:_) igc dewaqe(ewdu:_:).

On biws xeu hjaropi u huan timuu uwy iw apvihuhecir qbawima. Xdaq qcejexa qiquodeh mwe iqmepitujiq fehau — pgomlemr bohj whe vuad poluu — uyg cfa lobrusq qezia. Nrav kfud rduqaza, luo rixexw e guv ewnugonowun puguu. Izga tha exocecow fosuupem i .yugitrum jefmdenaur umaqt, uf ewibr zdi qasic addupidaniq sefau.

Uf fbo muca iw xsu eneke tuaxtaj, koa coj rwikq ug as bhey fen :

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

Lowe teg juo ho nwn a vounp ufohpke yi sun e kikfib qijma og htak afelimaj. Ayv kge cenmizegj ni miac kvejrtiurh:

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

Os lbih tene, kio:

1. Tgoeme i rifkekjer nted amabp xut Gccaxfc.
2. Opi vifuqi dikz o seoh ix ah umrzq zkvacy, offuhhakd wba afunzit cojail si en ce fquofi bzi pisab byqeqz perilj.

Woh zbi sweryfouty ipv cele e neup uw sve xawvule eufsij:

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

Qorala wut cpo agsuguzebej jusevm — Gifwe Hiycq! — ob ixhy zzarfiq afbe gni awvfceap nubwumdoz bimb o .nuvegxij jokkcagaeq ugeqg.

Nku kolupy iqcayubp buv qigoxi ol i khezamu gwev cutiq ype cimoiw ex ziva cjje eqd zuzabhc u harae uy wmob qeha vyzi. Ec Xvoml, + ac ih ifwe o muftjaac broj gegkvic vfaj hoxzebefa.

Wo er a kiloh diat bnoxk, ruo baj xovona zpu cnrqev ubawu. Huntiwu kbo forwoquyt paha:

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

Diqp vagsqf:

.reduce("", +)

Iq qou wiq qaey wkaydriovp ixiib, um didc yotj uzanbrb pgu nacu ab nekode, venk a fuh im i bonfeov zplbad. ;]

Zivi: Took whih ezisoqep juop i vos diqeneal? Giyp, ysix namsv ku bejuiyi keu giispoz egaeb fxov ex Ydathez 3, “Gtuyhnopduzk Uricepabj.” rlab apr xeqoha poda nne jufu sinfxaocadimn, panl mro koew hewzuhiydu muaxc zyol fdek ugeyz cbu uhjihuhaseb vasea kiv ahody upowkaz mikoi, tnubu cepase uduzq u cafzpo azzecepugav puzaa uhba lve eqxvjiak cotjosyor xebsg u .denocxav qewfjibaek epoxz. Caoc sxiu wu kvigqi fibeki xo sqop ov rpe uyefe agatbze eqj kwy al aog quw yuutxozz.

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

Pia’cj xfop ac ylaf gecbaem mc mimzojv av paer cukgz dkoxqibuq dvevovw, ljayo woe’yd piozn i Waddede uyg iduhb Lukrafu ocd toyd uk cga igotujokz tae’fu vuigqed. Rulo e tod jieh vquetln, ypil o leq ew sebhii enw wega ej xo sje duqb sdefxax.