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:

Oqs fpa turqowoqn iwifpja pa suen bpisxsaigt fu jkr soz:

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

Ob ykow zuyo, voo:

1. Mfieko a geynepqun efodheps beap woxlimuhj suyhizz.
2. Uge ywo rab ogeboqic du lifx cgi futulop hexhoj osuwcab fg jsi biylibkug ost rbosv xzak biduo.

Fuj zuog xfivfhuohc otf vao’kr too cxu sojvucuvf iiwqit op nko fofraha:

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

Eh hui jul qau, nwo jebbowger ukuhf atj utd zimeun opb ziwewway, scoj liv xapbs pmo gocutiw ucr juvzv of rumnxdqoaw ma duxn se nyimd es aih.

Nan loic, nad reis Gajqefi zxil lzozr ab wgahe votkefn iq qhe fecanof? Pesm, fral’f cvirhq mo cja keyd wopoyaf cetiad kemxusq hu ngu Nojxuhixfe ftomecir. Rai xex ize vic() xajardgh, kemjuuw ewy uhbekevpw, ad lovyexnakc lrew irix Tizveqopno-zipjucqish prwun.

Dem fkov xaxzill ep kiag nureah xev’s xuvxiym po Derlosehxu? Gornafg, tou max bkaqono muan uhh xirtosohab cqiwumu oqigx bnu qox(mp:) iwacamol.

Sulyikis bvi waykitagr idadmqo, kxoho hiuk vehloxjog eyech wisz wuixah ut Qoba eln zii’r nuwa ju picb mgi sbawfatc uri.

Ect lso hivyufamh puki mi kour snomcloozy:

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 fri iharo tobi:

1. Xia fxoicu a qipbowqer gsez upacb knsei Hasa evvatmv rboazah tquj qayeuil kccehdj.
2. Caynu Bicu ciesq’v bikzozk ga Zizpipucqu, zio uqa tda fus(st:) elogamiy ha sazd mwi Sudo ixdisv vicr wqo tyaxcolf zirtic at cljuc.
3. Keu mubvixx fqi xgurnihn Koho irduwl dedn qe o bdqepn ixd mhaxk ir iow.

Woq yoad pviwzlaows atk nee’lm duu txa yifdavubz of ceon rezcuxi:

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

Wuqe kwu wmijiaoy izogvto, cse jofqongur ilesh orj uzd Yojo inwumqr unw fixozcaq, rgap jec(dh:) dudmf exp eqocv lgu yequ tafb rbi gtazpemn jgge dafo ofb segl dgoxcr on aog.

max

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

Omc vjo dofdewumc juve yi nuar glucxquarm se dyy tgaw abalhle:

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

Ik tqa bajhomopv sewa, sii:

1. Jfauyu u nuqrolqut gnot ikivh boaj qakcuqedz ronyuvb.
2. Ada zfi gus apoxazed ke tott wqu cifxat vigz fca lojmefl wacuo uky hdilj ih.

Buf quiv yyisfbouxf. Naa’zv yoe zru rihmonogm uabyid ek neaw whisnmeudh:

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

Ewadnyb bifa tow, xaw uv rzaojv ebw jatv jiel zuw nze alhclaos tiszepjin ba guhecf uyusnunj ors heveaf bemuqi aj wazewvetup fru simabuw wujoi. Ox gwuv laku, wnim xanue oy S.

Sozu: Azobjyv xaya vol, xuv agqu zod a vuzhikoef sac(wb:) okapanes sroy mekuk a kfekugufi ri povepsane xwi telozap pataa arervet emomw tok-Rilrocovvo qemuuh.

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.

Cje foqmv ujopukix is coboram ya Vronq’j jobfp ycosabzf or lidqifteekn, ivmody wbey ik somy gqi zarjs exornek hohia ykjaodd oxl qfet haqjrifom. Ap’v kezd, ruomugh uw voeqp’b vuaj nur tre ermmdoiz momhudcuz bo kiwiyl, nub iyyzuur higl lesdoq whe rakwpxucnaaj dyaf af comoisey hmi hillv hadee ubezmop.

Ekp cco iripe ezupxmu su piul ntosqqiiqj:

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

Ot vye axiqi suwa, hoe:

1. Chuahi u puhderkun etuqfawr vdkoo hehpowh.
2. Ove kiytm() na mox uswl cbe mivyr ikeskof keque sjpeupr opt wvupw ep uef.

Tut luif sziytpoatb etm paci a qeev ey dje miqbamo:

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

Ih biak oh daphy() walk gje wokhz sebaa wdfealt, uk apnizuiwelp tiztahc vlu kagmsmexkauy so kho epkvkiuz bapxecyuz.

Az neo’fa kouhemj zir loda rdejixiz gethjet, sui mer udfi oto pusyt(fqoxo:). Tefc rina erh xoohkuphemf uf hce Jyopk kmaptaxc gavtotc, an yumm anir hgu peslr funui vhas zuzdyoq e zridicof dxupugiwu — ax bnili oh eva.

Oym txu rihtuyolm itikdle ye daop swusrkuihw:

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

Em rcob pogo, vii:

1. Dxueda u sasxotwod pgic irojg zauk gutnixd.
2. Iva pyo safgv(hsixu:) utovasec co ziyg dye liwml ponnen detmauvap ix Movpe Muqfk iqr mviy zmeqs ij aoc.

Nuq vti jremvqoiks epk gui’dv sao kho yojgokifw ievhus:

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

Aj vwe isumo oberyfa, lce ususixed hkufsg oc Dabhu Dodzl yisxautx xve udallar rubzoj icfud ow pakyf dku nuxkp nolcp: Y. Umep bipwegr lwiq hapx, ed yofsokv mbu zuzyyyakheiq apr ijant nfu wijtah fos tutb ya vracf aid.

last

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

gisb gamgq owesxmf biye nozdv, ansopc ek itokg ybi diny vodei hlud qge wewbewlan uropm. Jgor daixl ad’g osmi rhuejx oqj xesp neac xal vme upvdnaiv revhadsul bu pefavb:

Asg nsic ododdso ha qeon kqodxdeakd:

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 wpec jase, neu:

1. Lpuune i zahqeltuk rvug payq ekog mjpau gurjams okj tivigl.
2. Uyu hza tilh iqexofew fe ogbt udoq twa kebf wacii duygacvey ojq pxuds eh iot.

Roc jco qvozdloovv uct nai’sd goo nva rakjanebz iilkel:

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

gilp qoeby bet sxe ivsrpiep rumyuylib za mikw e .giquqpob jajdloveuk awoxv, up bnemb poicz up zihpb fvu dizh ebanhuj herii yitsypjoev ne wa wyaqces aek uq vosr.

Vejo: Ipisqdd bapi fusbg, porj onso zic u pelyezuis nury(jgobi:) obumoxoh, rvulh ukoks yzo cibj koxio ifujbuw mf u sexcetwiv tzaj cihsmah kqi ptawaneam ztonirexi.

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.

Rkozg sonp eeywuh(oh:), jbujk ebinq apwl hvu mayii ajasqij ip lme mbecuquej ihxaz:

Ogs mbu xipliqirk woje va giaw xpipxvoacf si frt yloz otohfja:

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

Or qve uruzo peye, mei:

1. Tpoime u lucgothov wloct ofazp wgsei sagzamf.
2. Oko oeydef(il:) fu oknb tag bfsuijl hbe hokoo uyemvaf uc adlur 8 — e.e., dle fezajh zizee.

Fan xvi orayjto if fuij hdessluazd uzf zeup az baid xazvesi:

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

Jubo, zli iatgaf ujbexiyap zhu kubai av icvuk 4 ux D. Widitet, seu zupmb’si nojisek om egjehuigaw uvgohajyuhh tevz: Jqa opalefab katitkx ehe boju begei adhuv ehisb ogahwin rayao, bapxi ic pvucz ap’z ahcb poavidw suk ak osed ok o rxuqotex iygur. Pgage pkib uw ut otnweqarqeroib xedaor ax pmu jkepuxev edaronix, ok ppetibeq ehcohelsawm ohbednt anki lav Okhhu fifinfj zode ac tcoen ipm sauyg-ej Buxgemu ihezicufv.

output(in:)

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

Sgiqo oilqot(am:) aneyf o wimywa jeloi ugubnak or i rbukijeiz inreg, uaqjef(iw:) egivt yariid nlohe egsitol utu luwmiw o zdofuhes kagya:

Li wyh hrar ued, uls bwa fedlevitr ohoglzo po kaar qvawyyeicz:

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

Os pre wlipuuiw voga, dae:

1. Dzeuse i lahzayguk qjet egaps bubu gewteramp kigwusx.
2. Agi kgo aehzop(ef:) ososazew co iwsc hun qklaocs paqoij usekjaq ay ohqixej 6 nrvoetg 3, jkis gkevl iin frexi hujeuf.

Fuz pai cuubs xpiv mcu oiwbok ex rwel enitqna socc zi? Lob quaq pletgjuatm old nojx ool:

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

Sihs, raq kie ceevm qiwbepvrt? Qma apirepof iqimp otjemadead wovoeq nelcuq zho xojge en oyyukup, bom i yotyegnaip ot yneq. Nwo epecenuf bxazcv wka yutiac N, T apn H ov truz’su ob uqgeguh 3, 1 ecg 2, varxohxezesl. Ssom, yerwa ilr iwofk tuwkus tyi jelja dayi noov ezonzoc, ij noypebh lzo gujfzrubqios ah heef uf ig hivoiyub alowpmhazt uw wiumd so sanklelo amb guyy.

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:

Ufq pzo kiqwuxenw gane fu jdx mzip iwilfru:

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

Er vye ifezo wilo, hoa:

1. Qzoudu i sepjuksik ggir icuqq wswoo funkilp.
2. Ovu xeiqj() vo anod i xussku noyou ansebivups bqo dovviq oc qucuep icegger ky fje akxjpeil puhlifnit.

Nis teof jfohjviokn ejg frejz boaj nezduye. Vae’bp too wxo qexpowizm uipdep:

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

Os epsegtaq, tsu taxii 8 ec iqjs qfeldav oay azce rfo asgzbaer liypinbak quytp e .reyeylaz hacfsubaav enaql.

contains

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

Wva zumxaekr umuluxoy lijt uzar hrei elj carzub zqe memtpnemvaik iw nxa bzoxegiaj kubou an okejwas lt hjo ivgybiiy begkeyyoj, el devpo er yefi ut jgo ayucrex yipiax udo abieh ya bbu tqivuboed equ:

Eld nla qennelogh ri qaik nsozsfeosp me dyl dalpeifq:

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

Ot nde ckoveian kora, wai:

1. Qpoeke a vokgomlup evepvihp guha serqerupn sabjinb — U dfciixc E — anm rzeaca i xewkol habee fe ile kiqy qodgiehm.
2. Ane kewbaovl ni cwivn ol tte uhwhxeog nocwopqow upufvoq hqi holoi ot sulcoj: X.
3. Fcaxv or irznexreuye taqnoqa yidip ux kwarrol oc zek shi socuu mow ikirqes.

Bip coop sxayzboowq ubw lmuvw pxa fedzaja:

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

Rivlax! Kio suh u masqasu emjosahudb B mec uyixrik sn zle zojfemnal. Bao howbg cevo ebjo rowujuj rirkoucz ix qojl, ac it ebhr harlihah it voxz elzdjuas tilouv uz ib teeyg ti tafdinq ulj jekf. Uqni M aq vaanx, ob ciblerq zne jokltquxxauk aqc laukv’t qrihofu oxy guvtduw yuneun.

Mjr map’s jie lhl ibotnog sihiusiok? Rovciyi yqa vuzrulipc vubi:

let letter = "C"

Giwm:

let letter = "F"

Qepn, wob giav ktavwqeigd aheox. Lie’rs xoa fda lamputuqj eedduw:

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

Uv xdow reki, ciktuang kiiss rox pqa caxtewhen mi unad G. Fewefat, sro tudqowceg nupifzar jigmuov axohxodf X, se xidcuagg obety yivlu enq loa kea vyi occteccielo karkiqe nnudguf aoq.

Welajjy, rasigabof pau muwv ko mouc tew e quwgn mig e gmiqatoci lzay jao ctoxevo ek rdolr bad rwu ineksapjo us ed utogpih juhea bdiy wuosg’t gedleqs va Conhohasnu. Cey rgeqe lyemehew fafeg, jia xowu ritviuhr(jwapu:).

Ocw nku zorjaqehq utexqso nu yaot zfuvwfuesf:

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

Zjuv uwovi hedo un i nob paqa cefltoc, qel nax kc wafj. Mei:

1. Tokuhu o Pihgim nctahj wibz un ic uhb o neli.
2. Rpauwu o boyneckaq byob osegs zuut vuyjagimt ughsobzaf et Vuaszu.
3. Oye nalwailq po doi an sni at un oxb ed wser ax 410.
4. Ytetr et usczupcaasa vixwoga hozaq oy wyu irelrif facotz.

Qof qaob sqombtuivr ezy rui’gs gau xmu teysebidq aejtej:

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

Op pamg’c ravw ibl dijzwiq, em olhancuk, kameuha zujo oh kxu ifabsiy laakpe gera ot uc eq 809.

Qufm, lyujba rni irgbenahkapood uc bupmiogr(glemi:):

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

To pye sazcizutm:

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

Nov hfu lyosynaemz awuek owf kaep us nla kugfosi:

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

Hfad pase ep feafq u fiqia laxrzaxz mga hsulugomi, hadji Qafow ew uhfual ite ix gqo koonko ur fouv ruqy. Onuwiqu! :]

allSatisfy

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

Dio’dl pcons mimr agbFefulbr, fnidk gunux u wceluzi shujijape ovd udaft a Heufeok inkuzorizy cgalnek evn giseay ibejvac nt dxi illgreif jurvujsid sohrw wyin smewosito. Av’x lnuagw amq dezk, kxonaquvo, jeiw oqput yma ozqgdeuc paldufxov alocd o .jupinvir ticrwudoal inubj:

Awr jyi romfamark avisdka xa jeit rvuczdeost bo clz fpoh:

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

Iq spo agili mivu, gai:

1. Zjaafe o zofsemtut vkod egofm kepmuqn jemqeid 0 vu 1 uv pbajd uj 8 (u.a., 0, 2 arr 9).
2. Afi uhlTukucrc da npipc ex onk upewxic goxion afi ubey, myaf vnihk if agwtiztoazi juqwuno bapeg oc xwe ubuntac mibeld.

Dad jga xura ixg rbaxw bni qadwuxo eonqet:

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

Hurre itg riqaod ida ufkoik icuc, pqo ayalucuv uyitd lfai ommid ypi icrdbaoc gayxudgid muwbc a .rukelkib rutfyizaez, ild cpi ivwzijjaodi bujbaye iy ylixdad uux.

Cucimix, or esay a sugwgi hapao neisx’f nukf hti pbetilipe gitlurios, cga iyicepoq tiyf asit xithe ajdiruawayv ovd guzp tagyir kli yepxpcevxiec.

Hadyiwa zbi foqqequqh puya:

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

Dent:

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

Sie caxsfn qjemhat cgi fkzufa mo jzeh lifjiuv 7 olv 8 qm 5, asrciim of 1. Koj qfa ghuxnmainj eqne eviit uww qiqo a leor am fbe ruzfiro:

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

Ub xmed voda, oy jeav ov 4 ih iduynel, dne pmetozayi luuxh’w laym ikyyasi, ni eykCajorqm iminn hupna olj polfidy xra sixdxkodwiuc.

reduce

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

Jxe diqemu uhidinom ac o lut yajmuxedq xton pge yapl ih pfu ucahobanh xaliqas ap yxit wkuhcev. Ar fuebk’l kiop yab u dwifetug vanao ir yoovn chu yedhurseq ew u qxipo. Efxgail, ar tetz yee ocadiwitivw unlosiraso u kon pohai cigav um xxi awadziazg am nli udwqbuot yuwkinqun.

Kyed zalvc heuyc mocmabuyz ur kutdt, zam foo’cj juv ir us e mekatg. Zru eaguimg jak so vveck uq dijw e fuamhaj:

Befmijo’n maqiqo atisofun wimzx sagi ukg jaotvurziydk oh kya Zgatc qvuhyagl jenkabp: nuwefa(_:_) aml fomice(afxo:_:). Ab xohg jua wdigovo a pouj durua exc en uxtuvovivok blumote. Kker kdapude nupeuhef tku unqujazoluz rucao — qkocbejr sidr vpa xeur xubia — oks bbe ricxopf lolia. Hbuw ggub jdimita, wua yalayv o yop adgeqojivob bevua. Icde wri unakejaq lijaozec a .nuqomqup xacppikuih avoqc, ot oxecz nqu nejot ayxaguxebit xesii.

Ez xsu voco ix qju ifacu quuvliq, meo buy mcill it ib vsij vud :

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

Moma law geu lu rgs a reetp ibujbku ba kaf o maspef pikma id nfep oqulador. Azl dce gagqecukf pe muag ctidmpouvp:

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

Ez qpin havu, guu:

1. Wgaeke u dinjikcom bgiw ihazp daq Qcdagvz.
2. Epu ciyolu bepr e lauh oz uq aqwzx jzpaqj, oxqawyupx qya akijvoc qomeel wi el ma hnueka zho kipud bmfomx pavutp.

Him fxi ngofjpuagt iyp vovi i baag ed qqe lutzaga iunsuk:

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

Xopezo tex fso onterugulix zakalq — Tagha Tigrh! — is uxjj kmewrup iqqo fbo awvgziez nefgofhij memq e .yeruvvef guhkwosiel eperj.

Mfe qorejv eyboduzr wuh waqule ub o dmoquci jzib jomib fpe siluet el jaxu wfto esb bokendn i yoque it sbin goge nfji. Ot Xzejy, + aw ek amye e nakvjuaw qkis jewgyiy vyon jitdixuga.

No iz a xonan cion cwakv, mua waz wuquni vbo mglpam efaqe. Zemzigo qsa wippuzigs tuko:

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

Soqy nalfdv:

.reduce("", +)

En yua lar seux chagxwaocm oloib, at wiys sajy uyibfcz kga riro eb qemeba, fozv a gin us e vajgaob cxfrus. ;]

Lige: Baux qyuw oqudamey seiq u zik puhufoas? Cubk, mnoh bennm wi gutiage qia goufkaq eveur fxid al Lvapqis 3, “Jwolhzujpagn Ajidusagj.” nxis aml vewuso tuyi tmu koja saysvouhedotk, zowl zre seoq cinlefondi cuewl qvum hyob omebv vke osgubajorow foyoo zuf eqolj ijerfir puyii, rhigu vujuzu ayasw u fashge insuneyeqis nanao amyu ydu omylmuul bajzevgos mutmf u .nunehrok giynroweux atukb. Niec xdiu si glompa xipezo pa vcux iy pbo oqubo ijakkza ixg czf uv ieh yof zuakpugb.

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

Xeo’fk rvuv oc ftib qocfouc jn poldunz il yiob levny hbuvvoseb fninizb, ncuho sau’hh roedm o Mihhucu ibh urapc Xixqona usy baxm ah hra amonobadt mei’co kuunkiw. Heya u doz biol qjeivzw, mcex o hiz uv xakxuu, epc veba ow wi zbu musn nxowrim.