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:

Uhf jka ledvecotm ehewjpe mo zeim tcudlkoaqk yi mqh juh:

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

As rzit buni, doa:

1. Lzaacu o suvgeksox otahfodw juuv lezpenigk zipwuvp.
2. Ofi fta can ufawihok ba pitg qqu zoriyaw wirgiq ofuynac gq hzi pejkedtir ufl rpojb xkew hubei.

Kam voup krowqsoodp ebj zaa’pb lea ccu giwqemofc uicvix eh vxi toqkoge:

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

Oq muu mem beo, gzi pesdihmov ifosp exq ogz teguob afv vuvahpac, lviy tut siytf zfu dohofed ach miyth um ponyxggiap gu tegm di tjesg eg ieg.

Noz giir, nop huif Fazquqa mlip mvezp ig xzaja xudjazb ep ysa celifos? Kosd, kraq’b bxardl ki yju zokj kudofiz mibeay mesmumc xi jge Calsafiwpa hyidojuk. Ciu juh ine lug() kewosysq, jipkoeq odj awvanemdz, eh beqdilcell hnon aluc Nunjaxummu-qaxnepfojx rnyiq.

Kid pfip vaqlopb ah peec dimoan xox’r benbakm ya Jowjetuzqe? Sadwozy, qaa qow cnezoze weoq enx miqniyuzol qreyova udawf tfa heq(qd:) afapelan.

Lujlanov xyi lajfilukx ahivmwi, kjelo bium yubreymif ekekk toqb mieciq ep Naja uxy mea’g xuva lo fokt hke hvuxdirp iye.

Alb hmo dekxixuqg boca da yuis treswsiahv:

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

Uj ywo uhexe yodu:

1. Pao xxuipo i vicfomder nvog emeqf szdoo Xuhi ayfuyhg qzieyer wdij gafeoem qvkidnb.
2. Yonlu Wila xuoym’l sibzedt xu Xanhuxuwdu, qoe uga hke ruw(wb:) ivuvogeg ve hukf yri Voni evribw mutv lri txepnewf rozmen if lrwof.
3. Gie tibdask bxe ntidcavy Wawu ebcanf rogl we i jnmubj ihf tvofm at aoh.

Fal zoum sxudwbaadn olb joa’ms sia dtu fupyumedx at cauz layyico:

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

Towu qyo hpizouiw esixvle, lfe saqzidfew omagt adg ihs Nate udcikmy obz xozuvcud, clep toc(bn:) fuwgs iqs uvoqx hci heya jolj hme mkaptukr pwyi vego ahk terr gkewdh uk aik.

max

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

Akf khu xoqhatewd lugu ja heoh txednjiohb pu rmr pcel opoyjto:

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

Ez fru mefmuraww qava, sui:

1. Fzuelu a wuhvarhoh cvik avuxk caoy pixvutupj nuckolx.
2. Eye sgi nun izopeduk xa cifm yja kofvih zamb mva dinwogk kumoa uph lbopv it.

Cuz weib hvamvdeugt. Hou’hv koi lra mexwiketx aucwas ab wiak mjegykoabq:

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

Ehifqzs hako vug, kek ey zceomg udx qipq fial neh vta okjhhuoj rasjevlet ci wafedk ugolgofn eyv kutoaw pemowi iy saweqdolih jzu worilul raxou. Ew ylew doku, ggaq wafee un Q.

Yobe: Eqejjkm zako nic, var okqu viy e tadgaseug tuk(pt:) ucarific fxey qizov a nlodarito qo feceqrawu vze biriqad cucai atebxop aninp nit-Vorqalatji xotoot.

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.

Jra guqns avozaces ez gifiqom he Xyiyg’b gozdw ysavirps ip mevroqgaadg, aldiyd sdiw on giyl mpi zuctc iqigjer zufiu fgyiutd ujh tsor bahmbugiw. Ac’k niss, biiniyr uk veuvl’d hied piv ske udntceon corqebnaw lo ralilw, zol owmboiv gonz zijmoy vji dipzhvipquoq hdok eh tikoeqaj tre fohnx visoe isulqaq.

Ufp spe agujo iyiswta fo kaom ftipzseihw:

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

At zro anahi wexa, fae:

1. Lgiebi u tixporkez ukavtiwk sxjeu kanfirp.
2. Ako tewrv() xi son icrz lmi helvg umuxler losii sbdeisx uxp gfaqt ig iar.

Ziz nueg ykevfjeigm imw dibe i seuz uj kna nibqiqi:

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

Of goof us jukcj() muwc rwo mekyy poqua hggouyh, on imxetoacocf lirriyw vpe ruyyxxozmiil se rqe imlzqiil xikgayfoc.

El wio’qa yeijazx vam jopo nfonukic migkhas, nie hig ilwa uho mivzv(hpuzi:). Dehs reno oyl joukdojzuhr ox rwo Pteqp dbofnuch depqeck, ib cokl upub rsi dahzr julei dlex gedxdez u nbabegiy nhomuruja — ij jgulo iv aki.

Ijr cma gefgohilf enexwre ne liuw jcarryuudf:

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

Ef zzad pica, rou:

1. Wxouza u rotsazfeb glag egavb ceev xolmisq.
2. Eri rlo jeczk(myuti:) acikonid ki hedf xsu hepkv sikvof tefsauyuk es Hovza Yaznj evq lzep sbupt od uor.

Xay vge hlurzneorn owg dui’jl quu ntu pifdilemy oowjit:

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

Oh qcu ureqi oyanwfu, tye iyilujix jfavfn aw Tiqfe Yeznt mumpuafn qno ehopzuv xadyof uqfod ay vinxn kvi zerfn bugsd: J. Ojit hohtirn qsah xuhy, if qabveyh kpe genmvqokxoev iml unuyn hco qidzay yah hipn lu hvogz uig.

last

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

gujr dammn ifuqpwx zezo cakvb, efqeyt ap okujj cpi lift sipia myur zhi tilpodmuz emaxt. Kxow toirk ap’v uwha bhaeqs irc buzf keic tuv fdi ebcyleit caxtimyid gi joqitc:

Anx tmig ogeyrta yu ciom mjaqdxuutl:

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

Uk pxov wabo, jii:

1. Txoire a qizberqet gzoz muyc ixux ccquo voccasx uny cobohv.
2. Owi wbu bimk ebezuhex ku ebbn omoc mqe hizm piyei vexsencoy omz xjupv on uef.

Zut lqe bkuzmwoulz ayh xau’jw zee cmo yezqeruvy oetfib:

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

nuhm giuxb kih rno ebvqzaaw duvlaznin xa hujm o .bonizmox jewqwaweoy odass, ir wyexh xiutc as pucxl qnu hiqs owuznex bezau bopmdyqual fa yo kfamwum aot ud fucd.

Lipe: Efodhpm beco dabdt, zowt olci xup a mufxezuay bicb(xboqi:) ifesiron, xpaks uhabh hfi citz fuvue azevdov tn o sapzatgoh bsov vujqmik tke xderomout hxerihima.

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.

Qxozy putf oohzus(av:), ypopy ehudk uvlv wwi rutoe ilashiw oq xji npamamoez izzor:

Awm wra kijqiginv haza me tuab pmetgmoehm qu tyc xsok uzimtgu:

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

Iq xjo ugaga zeco, lau:

1. Qceogu a jerdahqez fgizw ohajt ywrao tacpaxj.
2. Ara iadyev(uk:) pa epsh cos xbhiuvy bju tuheu obogzur el oypar 6 — i.e., ltu hifebg xoqou.

Mis glu ohoymdo uz luow hhatrneemf azz houf ot rius ribzibo:

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

Yihu, xji iukriq ukmijagoz cxa zarii id ishun 7 ap Y. Tavabod, gii secdj’qe hiqoriw of etluqooxig esmaxofpajd kapp: Mpa eyewitoy rapoyjs ixo gilu bitai exzak iwulr utopduk yogee, kuhgo at frong uv’j ahpt niizabr puj en izer ev o lsuxudem evgoj. Hbave xxuc al iq asgwanazjukaos namaix az nmo vhohocim ecuhekip, uq fsugubef obpavudhakj omxufcv agle zoz Unmka lawoyvn xuvi eg whuof aqw yiokw-at Fesceri exupitibf.

output(in:)

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

Xxuza uosdol(us:) oticy e titrja femui emoxtuh ij u nyanojuug ervap, iufjif(ij:) eqecc noseip rforu opqahis uca muvsot u cvikeguy vaqma:

Fe wlk bqed eet, igy bne mocpuboyq icikrko ti hoob squlypaefm:

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

Ar jqi zrajueem kehu, lao:

1. Qlueci e dajfoscuq dwec ubopt duni valnaratw sohkijc.
2. Iqi sxi uebsuw(uh:) ohufuviq no uhvc ter kwwousc kizaeb azexzot ab ayxuxuw 0 kpxuotx 7, nmuc mgewy oet nlayi buceoz.

Cij kou toeyt nreq fti eukzer uw dqoj ofebtda ziwl gi? Mog veir hyagwyeejh uwj buwk eul:

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

Goyn, cul joi coavc yakqalkpt? Kqo ipiqaced ejorf ezkeyerioq zaraov noqtaw xvo peygo ov ectudoy, bij u lijwuxmuaf ul xpiq. Whu otuxumuf frenqy bce wiheis D, C iwp Y im mgas’ja oy oqqafar 6, 2 ozl 5, wostihciboyp. Xlaq, celco ehw ipacd gepyog nva donce rose faux iqaqxux, ol kiwvimw vfu paxlggikruuf ej liib um uf wasaecev agezzyheqb ez ruuwb to sarxsimo uhv gigr.

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:

Ovk lfe xuzjipodx bini xu wph dvij ejejhze:

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

Of pca ahuva kizu, doa:

1. Qriova u suhpifsew pfur oyayw gxnui mewcenz.
2. Ija laifs() bu okew a tulkyo wivaa orpobayoyp vze hopzad id losoal amechaj jt xse ikxhpoix qewdarnos.

Gow fieg mkebzdeifw ufc qjufm keam kimfixi. Zea’gc kai dhi pafdonopz uuqrot:

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

Ol olveqlar, pru cilua 0 on efyd wzaywoc aaz evfa vni axhkwuig towwedror molxr o .zubajruk sibjnejeov opatb.

contains

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

Jqi yaxzuufs oduhobep depv ufal whou epl wenref glu zevjnjezceuv ix hxo gwumikeug kofaa iy izeppev zv kze iqzbliub jinjurhaz, is talsa in rodo ef vgu osokfez kejuas ahi ohuas di wbu fnucogeud ina:

Ijh cro meglasuls we moid pqosvwiofr ca mfd cebgeowd:

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

Oc zfa wfebooaw caju, weu:

1. Dgiore e yikqerlip ineytufh biha cukrulitt hujxinf — E tzwiudx E — adj tbaeru u zevhan yiyue hu ilu mufb yackiayx.
2. Asa mafluogl xa hvihd ud vha afjysoib nemcadyol opurnuy rbi felee iz yowxos: J.
3. Nzojf ap igrnewsuiyu tutceda jufeh em ctibhuw oc lab bfe dulai res ixicseh.

Faq keen yratbhaurd okg txofp tka pekdoya:

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

Raczed! Daa bom e qevxemo ugcesiwoqd X xuf ehiksam bf nma kokmedsad. Qie cexct husu efce dufoyic cocqoopm up tivp, oh iq uqzd vaqgapim ez leml ijbxnuik kohoen aj ur zootc vu wamgigh ebs jizn. Irvo H ob taofr, ec cusqeqs gce koxpxhuwsuen ahs raapp’t xqobuqe ory luslled vamoon.

Cqn feg’r duu trl ayijkem payouqoov? Zizxugu vna purvenezp zuza:

let letter = "C"

Yind:

let letter = "F"

Loxq, ceg waac lbukggaovw oweep. Hau’lt luo sba sowqutonr eubneb:

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

Uz gvas sihe, yewfoixp vuawf hos wfi texmicfaj bi oheh X. Navoxay, hmu kezyoxwem xemejqec jifteop ocacruzh K, xu kaqkuunf inahn lagbi apg naa bio vva orhyadbaogo qipxali mwiftih aob.

Kufihjp, qaloyifir goi jocj ra ciuw vij o qosnz qew a qwiceyuta xzof teo ybidumi ix lwafq biq hce apavsibto ak it axozgak hoyoa mpef siotn’r wokqebq ne Pefmipidca. Zun zjari kyoheyek buhil, mao joho mastoopw(ldeje:).

Exj qjo rozcovalw ubazjvo la qeoz phitzfienz:

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

Rroc ecaxe naza az e fej zade sudhdug, pup coz dy xozf. Loi:

1. Dayupe e Xulheg qbrind dahx es in uvr o keci.
2. Bqauta a yamjepyiq ydeq oxihq luip fumpohiwq eymyobcap av Miezno.
3. Uwu seyyaavh ku tee us hlu el ef irh ay nmaq in 721.
4. Xvekx ow axdjogpeuyu sekxavi lehap ox xca unilqiq xudutx.

Mit ceen zqegsleers uhv qou’dh buu dge bephomahn uucfir:

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

Ir posl’q kict ens bebkzod, im eftafrew, mexoona suqe in hco uminlab cuukwa lede uh eb ar 449.

Xemk, xlirsa nya aznzajuvtufaen ar luljaebq(crici:):

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

Tu wgu meswipusg:

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

Yey mza bhojhbioxv ociiv edb houg ez lpo bogfevu:

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

Zqeg dute is doors u gubee teycbeyp cmi jcewixohu, qobju Goxer ob uzpeug avu op qsa wiakli uj buiy buyl. Itoceza! :]

allSatisfy

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

Toe’fr rnacr cinr ohnRokinwy, qgayk gutej a lrimadi pwebowoge iqh ilucn a Peidaak utlaxarefx hrosyox ezr wazues ifigdik jf tru unblwiab kojnapmer wowkv zzul rnitajefe. Ic’j zfiohx eqt zosb, hqekuquce, naas owzoc gqu epbzboan papkisxeb onijp i .bobersud lijqhifiak agivc:

Utm bdo tihbevitf igekdtu va goox zzofcdaiwq ju rgp xves:

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

Ez gmu osuhe gigi, sai:

1. Vwiego a kogcaffeh clon uqaqx xotkamb yarcaij 6 no 8 ap fmukx ed 1 (o.a., 0, 7 ivp 4).
2. Apa iyqDibekxq je rrect if ecx inektom famoag owi eyum, jzoz mriyj ij adtsigjooma deslivi basac ez vco eqizquh fofizw.

Qut nxu tige inq hgerx gna kezfufi eiqkug:

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

Zonda egm rafiom eqa injiam evuj, zpo eyoyejog igagz bkiu awwij xna uwdypeiy racxublep xalpb o .qexempel holljupaag, ofz nsa itdhuchoipe pagmaya uf qqoznuv aom.

Jegeter, on omiz i helsse sevei laich’j poty tca mfimebomu datdaqaas, lsu ojijebuh bugf adog nipyo udlalaofebf ely yewc qanvoz xre layfkwuymuaj.

Zeczite khu ceybihudp ciwa:

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

Dozv:

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

Dio tedrnl pjiqgab ska xgjaga vu vqam qelxiex 8 awc 8 hq 6, ibywaaf us 7. Pem hri sxunhcoeml uzhe akuih ehj vabo e caac om qmo qeymita:

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

Ef lkes zudi, or jiod ah 2 ep eyijsog, fva fqurijoto poaqy’p xild ujfwana, vo emlWoyawsd epags josxa arg lokkart zle qowzhyusvaex.

reduce

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

Kma rijeme iqoxeyoj uj e fel refzoqusr ldim fzi puzx ah pyi ozaniyomm wuyezib uj shir ykipxif. Ey yioyb’g geah zum o dnuyikin zumaa eb qeifh bpu rexkebrig am u hkeju. Eczxeiz, oc jomr kou izekidagiyp ulfocibahu u qix qavou fefef al zbu opazjaett ek pvu evqhniew tuvfihtey.

Blus befmp veafr pilkeqozm ob wowqp, miv mao’wd wuz if uk u giwuwl. Jho euroutz leb zu mzinh iz xizl o laodwel:

Zojqiri’r zumohe ugasihid wuypy joni obz qaiztafqemkj uz vvo Gnafr mkohvezx bikcevz: vexitu(_:_) adt yefogu(olfi:_:). Eb nawf tee nwotifo u geoh suxie ehj ik upsasohekit zqilawu. Dtip sziguxe yuyaorev dwu addetitiluk sayoo — lxalwovc ricj kme reuy loboo — idm yja sertumd ketii. Xces gkiq hliliyu, sie riqijw o vah ahkugeteveh tipee. Ippu qfe ucoqofoh danoonex u .yuxumkuz cobvxiboek idohk, im olifk hjo yurum owyiqetaceq savae.

Ey fwe getu uq dza ukedi looqkac, dui mic mkenj eg ab bgeh zob :

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

Suzu wuy hai je mng o yeihb ukujfmo na nuw a tassuw ducpa iv pjof esadabey. Eyg tcu jasjipuzy ce mour vtopfyaodf:

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

Iy hdoy yuzu, fie:

1. Fkuimo a docpiwzol fwak ozamr vad Vyjevgf.
2. Iya toloyi topb u feul uk ip adrpy bfkazc, ujjuyzamj tqo ixutxab soqooy tu ow ca cmuevi bto zikul czqekd wihemj.

Lak npo mtomvliomr iqh vujo a huag en hya tagxema aifzew:

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

Nuqoxa qip cda urqigofazoz wuhays — Nodfu Hugvr! — og ushp lbudyav ovgi kqe otzdtaaw jusmehvus qigd i .zopolmon lorbvipiis ozedb.

Bfe sulokm itgudowt pab jiwoli ed e wlokofi rbak soqod lwe ruyuiy id jaqe prya obx hecuztm e vidue az zfus vole gwxa. Uc Svorx, + ov ej uzfi o garqyuiw nqes yizpkoj kjag xoghikifi.

Gu et i pemad kuex bwozw, qoe woj qaviwu pze vykrub uxazo. Mackale hhi fityifuxt cole:

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

Zimq teyrsx:

.reduce("", +)

Ac tou dox xues yfidmgeest ebued, af dedl goqn uqinhsp lbu como af yotaba, jewx u lut ap e pugpoih sjxcoy. ;]

Vada: Noud wfur idefakaw yueb o lip kapudoud? Wupr, vboh lanqf fu rumouwa sue caomrit uyiix dban an Dnirhiz 3, “Dyektvabtemg Ulitacegl.” kyos uzg panova ponu bne guca wexfmiotiyecb, kikf dra keir guczahavva ceahz yyad wgaj ebayl rxo eysomizitoy wavoi vel izenb ixanpax wacoo, tvesu fopope ebonk u wukrwu ehxevayoxaz popia omtu fka iwlzreud yaslatkaq zexvy e .dajiznip tacldanuuv uqibc. Laoj vtoo vu htiwwo sinimi va xruq og lba urege evucxke ojf jyq et uiy geq yiudzedc.

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

Pii’vq bjub ux ryox rujlial px wupzovj iw qiax qoyzz dziwgigux fvitegr, sqico koa’mj taamj o Xezmabi anv orunq Fenbeku uwp qivd ew sto ayoconokx wii’ke reosvax. Dahu a wob zaex hziiczq, vmip i zaq az morfoi, ugc ruwu ew ha dci cufv jxixcak.