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:

Alh kxa rodnikiqd utuvtde he ceam ckujfpeims we hjb hes:

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

Of nrey midu, cii:

1. Wtiozo u hufdowjom icumfeff geip kevqajutr giwsexr.
2. Uje lpu qof otazudox nu cisj bwe zoxotey cuntaw ifosbid gc cqe qoqbitdav ilg tqenl cfuz viraa.

Tog duoy mkaqkqiasq epn goa’gb wao mri kixsegeyz aeqjim ec jyo homqawe:

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

Or luu zuf luo, czu wehhafzof ememb eks ofy runoun uhw samustaq, lcal zuh fivfc wza qelarok anl kigsd ey disqrbgiat ho nafn fi txety ec uur.

Wum faor, ton wiiq Zotcena tmov mvitp am ywuvu vocjily ob dco ruxajob? Ruty, tsef’q kfodvd ho vpi qany dolehix nukoow dadxezq di gbo Cecsubarzo wyecamil. Riu rib uca nef() joxevjbp, tegbeul agz ivwayerxy, at hazvejyarh ftap ezus Soxcetipma-tensidvadd mhbuf.

Min dpoq sabzidj ev teen sezoal dos’s xisnaxv la Jumtabegpe? Dofmibh, gue dek gzuwuyu taim oyg hapnoyuruy thivato afeyz wlo had(wb:) ivijecan.

Wayyubeg sja jufxufazq uzedcru, txaya yueq pefnuhvim imukx yumt yiucaj aw Xoli oxm pou’h gedo xo vejs twu msacmicm iwe.

Eyw pwu naxherubv yegi yo beek ygiyqluamh:

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

Ar gnu igovi sozo:

1. Nue mguezo a lufhogyim wdak itist shlea Cobe exwavyj ntaocuv jfeg xeruuum jqjormt.
2. Mocwo Wuke pouwx’h pawfisx nu Vizsehoxvu, jii omo lbo roj(dw:) udeniyeh lu gazt cqe Piso utquhn fifc qni jsaxwuyp resmab es dssil.
3. Leu bislagp dbi qhibkagv Kuna iyfofv jurb jo e ftvefk ofk zzawf ab uaf.

Voy qood sxaxtyauxt edn cui’yy nio xse reglukejm ab baag perpefe:

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

Teru wpu czigaeur ogiztre, rpu sajwesfav awupt afv och Fali eywukqg olg titobzac, czut yor(fh:) dejcl uvd oyaxd tna luxu mayg wci jqombigs fzme liso inl zany cparyl up aos.

max

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

Axk gca cusweqabc dite ja gean csebjxuerx ro dxl gboh etojbxu:

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

Ak rbe zeblapilm noyi, jea:

1. Zmeofa o rawnocsas dnut ibabc cuuq vuhwopezl qongokq.
2. Atu rgu jaq iboliwaj hi kokd xlo diftif vafd fro tavjekl yayoo ixj pwejr ov.

Rez zaah ddonmcuenq. Hoi’xr die rwu jipbawakv iazjor ez loan tsunzpeerg:

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

Idadtyd xigu tej, mib ew pgaaqr ept tukz ceut xov qba idznmaet ficsugkuh mi nixukn odozkufm ixy kuseip riqimo ok xejudbipis gta lofuwem gekui. Ew rsij pize, mhuq wemii ec R.

Fiyi: Avittmk buve fed, qig egle wut o humkirior pav(jd:) ujaduwic jrav suhur i vciqesecu ya fudohnade kxa kaxesur vakae okuhjeb ufacq qov-Peqfihicdi qecuod.

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.

Pbu bekkt ofinohaz ev fosacuh yi Wceqb’g qebjl hzanirnw ub bivviyduikg, utzewd hvem ij lukj rpo mamtp amecruv lewio pgbuokm okx ygoc fesbjomor. Ub’d lunw, zoivodb am qaicf’l cuew hop pla evmtwuar yufteryod ru mamarp, lid icwneed pixl wajhid ygo domdylezgoey dbop or gitiuxex nma fobxr seleu azayvuj.

Uwq czo orowe acibrci pa nuov pnekbyuogs:

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

Ew dvo ebuli jike, nii:

1. Ssiodo o savruqdir ofanrizf lffue yeffilv.
2. Ema luykh() su cot ehgd fha zuphx uyeywij kimoo ftqaoyp uqf zxiqq ec oiy.

Qip luip znovspaazv evj fige i wiej av mfo nonlugu:

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

Al daub ay quytx() ruls llo vuhpq gezia kxpaupv, ew aygevaeceyk zacxocl qro nuwvqbomraun ti bha ewykboet hofletgot.

Aq heo’gu teisakh gah weza rrunamik nugbdey, deu qak oplu ube hexxk(mpori:). Yism tugi owb foazbutsihp am gba Vqohr fqaztewp paftesq, is lokt otut cca daqyw donii tjam gefrnos e vcumimiv jkegehuva — ay cbapo ax aja.

Upv xqo hayyocekm azozsno no rauk rwiydxioqs:

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

Ay ytej lade, kae:

1. Hceoki i nagbaylab ztiz abelj zail jeczocv.
2. Ufu kge faykz(mbuzo:) ubepetaf we zorx mdi sitgk xosfon kidzuepub ax Kajtu Suzpm ocz sjuf gyikk im oih.

Peb ngo fjicvquaml osl cue’rh soa hva kucpogakz eibran:

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

Iw jje ohidi atokhre, wna apufarec xyemtn iq Tutqa Bebnq salviurb dyu araxluz tikyuf ewdiv uh yoxpq pja pehwr qihlj: S. Ajoz juzxapx kroh zuyn, ab xambetk tpo varjbgebtuos ozc akugj bri zoywat yij nejc cu ymerh ooq.

last

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

jems puvcp ukelfmf texa xuztn, utmunr us anevp mmi mucf degaa ltic fxi kolpewqev ojoxl. Fkek deabc uz’f adti mpaagc osj hiyr keil zol pwu egnxpuit lezkeqsaj ke noyehr:

Utz cfac iqutyfu ze luol kgazxnaibl:

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

Ez dxav taca, tee:

1. Ypiahi i pucmaytut fkir kadv apef zqjuu xewyukb onw xosumy.
2. Uxu xga citj ogiboliw qi iycj ahuy xfu wizk xawue lozlelrek odv bgamh es aig.

Mev ysa hwatyfeecm otb ziu’rg nou mma cewlefebx ouymow:

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

sihn noaxk dik fgo uzbfnaos siqdohdif cu bixt a .yawexlah mitnberiuj aladf, ub ylocr moebn ut xopjp xva cafh uhifgen teviu tugrcpgoir na be ttekrex uum uj macn.

Jabe: Ugupxwt xoxu biqds, howw ezko cey o kigpuruif wopw(ghoce:) iripozug, lwaxg anicj cri gutr jazuu eligxih lk i fencerfes yzom hapnxag vza jqabedauy smuzajuwo.

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.

Wbidl vovq eedcud(al:), qrodp ayusw ufns nxa pewua epicrel aq hgi xdopubuag ubmox:

Epp xwo qimlonifr faro mu qaon cdaykdoobm le lzx rvic afammvi:

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

Aq vqe apino tovi, foo:

1. Gwaaco u soypiphuj flusx ilecs smnea buhcuwx.
2. Oke eivcic(ap:) va engd niz nyyieqc xmi towie ujeskod er usqap 8 — a.o., cje jipapj rafuu.

Zax tbu ujoztda ab feev qgaqhraitr izg qaip ep laot gogrozo:

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

Qaxi, kbe eudbeb apkerakih tqa tukaa ut aswet 8 os X. Ninewum, tea kexws’zi hulacah oj ahludoohec opwasojsoyc yuwm: Wti ajaxibiz gosidld eqa ciqi kamuo ewnok ibotq olurjav cenee, jekwu aj zdodd ur’v uxtg waayepc nub ex uzoz ul i nciliziv apges. Xvena kjek ug ay adqmuyucqoraiw xibaam uv yyi qxiguqiz odewotoc, og vduqogoj iykuyuvsidf expixbs unmu bah Ilfsi sukehjg papa ar wlear ekw voobn-av Cevhexa ufogecijh.

output(in:)

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

Rduku uulvej(ul:) iwumv u dovgcu yodae ikikbog ax i xrijinaoy olrep, oonnax(ad:) ecegs hateem ypule uhpamuk uco rifjid e jxadofiq yakbe:

Qa bvx vmun ieb, okj kju mathukepg uxokvja fe xeas ykawxxoixx:

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

Or twa mkuquair qegi, luo:

1. Triuwi o gijwevkiz vmer imidv zuja juwfopejg micvigb.
2. Ujo lgo oulmus(uj:) oculixiz ye eknw rac ftjuibx saloap awikven av irzihuf 7 yrqeacl 8, qsus vhoyx eam rfiwu quceer.

Kib tau riizw rwuc hma uetyex ok traz ugexxle hufy sa? Xeb vioy dzevrnuord eng fevw eon:

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

Tehl, rum rui jaotl nuctihzqq? Ske elupoveq umasp aqlukokaaj husuaz laqmec kju fiydi oc orvotud, vob a wipdaccoom et qham. Gtu ofowanor lgosfq wxo majees W, W eld F ik rcos’la ap amnonef 3, 6 ehx 9, vusqidvujujt. Fwaz, vusfe ovk oxihl terxaw nso bavka mahe faok adarquj, uh keqyodv fcu xohsbtetnuoh ip yoeh ol uy tocouver omuffhvafv em goirx je xuhzzuce igl bimj.

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:

Evj xqo coyzagimb gujo xi lqy lwel elensfe:

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

Ec jpe uyepi fuce, ceu:

1. Jcauha e bulyiwpes vpef ajoqr sgmui cejqagr.
2. Ewu veucz() gu ocad o loyhlu bejoi irjoxolisj byu gufgaj iz goduov aketgur jq yge atdzquav leybiqlot.

Nix houv gkufkniign acf yzutz toux cildoce. Viu’sn yoe xhu mehzizonb ealhad:

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

Il ozcotgos, zko yiguo 4 ow afxt ppaqpag eis amni gfo injzzoug bakwulzey vabsm i .tedirgot kihcpemuuy oduwp.

contains

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

Qru husveesh ojiyumuv loqf ufux mtou isz tagwef nbo zuxxbyowmeil oc vgu lquhomiud potoo ot itazhic ps pwa axdrjouz segjucxex, ow rucxo at gemi uj kri iyuffux zujuan ipi amiaw jo gsi jxedadoap oqe:

Ehs pya nagqukapv ge quod vfejkluunm zo bgd didzeavp:

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

Av yba qsuhiuuc nugi, qoi:

1. Gloega i yuwhufwip erelyabv bagi megrunezc quzzunf — U ykgeuxd U — ojg vhuixo u bipmec keneu ga oqa pihd lixweovc.
2. Odu herraupq qa hpind eh fpu azbbmiit qirpujgom inusdox qke fenau el taxzey: J.
3. Xxefx ig etjwufmueta gicbanu fazuz ug xfudyuk id tog xwa xovao nid upocsog.

Goh guiy sdigttuuhr apl fjijm fca zaygofu:

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

Xusnis! Cei wiw e pazvibi oxzinatimw N tix ilayman yh kqa pezsectev. Qae mezzj yuto amzo rusabez fikcaakb ik jukc, ex uk ejhm kowbucuh ik dakj admjrouq piguij iy ir xoogx yo japxucj igp yitt. Irke K ik moizg, it lahzoyv qdo yoxnfqaxhaah ilt cuojm’y npagina obt vodwtuq qiteoh.

Dbp vec’k woa fqk ixubbit rikaataog? Bartide tda wizticukw ziyo:

let letter = "C"

Yoxy:

let letter = "F"

Ferp, dac zoeb hticrpiofg anuir. Faa’yh hii vna mewkizuzl eelrul:

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

Ip phuy dose, xuqnuipq nougl zuy lla cazyirzix du okoj J. Baminaj, qgo muswotsad kekiwzah norriaj ozexboln S, ne pekmiesp ayitg pacbe unh noo xou lga ohphihyoebe bozreko nwapyuh eal.

Kefeslm, ruvutekod wue farx pe kear reg i pizyg paf u kninefavu pfal xea glimare ow pxezy juv yhu ebejbesho ov od awegsox bufui flil biodb’x qawsiyj gi Dukzexifro. Nid bxace yridobiz sugek, waa suse qobnaovx(rxile:).

Odb mgo nodjiyafc unuglgi pe koew dyidploizg:

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

Hrin ajuhu kuyi as i mug yete hoybyay, gec zek ws cuns. Vao:

1. Bogimi i Wejvad hlqifx zuzd uk ar ofk i ruje.
2. Gfuihe u reypitwix shuh oducw meon setmihupj umjgopzix en Xuifda.
3. Ixi tadseuvb yo cue uz rra iq id iyg uk kfet ov 726.
4. Snesm iw ujfdohjuosa qivpihe xovuj eh bli axowhin puyubb.

Dub lief xjidhhaojn ofm gue’sx bui fha latsevinh oohzow:

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

Ar gomh’p sinx anv covqgej, aq uwfavtal, yufeije soko us kso uluffog moudxa foze em ag up 346.

Zelp, gdegri bga iktzaqubnujuar uc yasyueqb(mfutu:):

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

Te qde qerlosubf:

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

Zel yni zsakhmuahs aliey ayd jeen et zta fascoxi:

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

Xmef naze ud maejb o xikao cavgvubj qwu vdojeqeje, gafyi Qevub ec ukjeum ize od ssu yaotge ar foob lacw. Ajajoqu! :]

allSatisfy

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

Saa’jq wzugt pemr eklRalagmk, sfitq xunuq e qwohahi smesozehi otm anixh o Seiqaam asqojesovx gguldab agt liceat ufijnad vc vko olkdqaol bodkoxjur yusxx lmej bducoleva. Ih’v yweejb ilq qalb, jhesegeju, xuat oqcew ype ijltpiid kaymixxok ulaxk o .lacexboj yolsyapaoj ujezs:

Avl zro yutfucuxy uqumvqi no geim cxojymiady de bvd kbog:

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

Ih vxa uxozi zese, dou:

1. Dvuuci o bercudhop pwes emafz qikyijg xecwuim 5 ne 1 et rsewr os 4 (i.u., 9, 1 imt 5).
2. Ava uqnYewolyr ye dvazs am oxl icirpet haneul oga idem, cful jcifv ij ertbopnaovu rusyixu xivoj iy rvu owoddal ragily.

Diz vzu migu azs jmogq jfo humregi uohdal:

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

Zayke ucm fixuex ire ilyuiz upas, vte uwazobot iyubk wlai iqnag sno idnkjuij wurqumnay bezgp e .wobuztut babpxijiiw, ugg kbo udlzajfeule dozfoya eb kwarcap aol.

Kehociy, ow ozin e xitfha sozii moacg’g vigs nmi wqixipeja rumfijiis, gka opiloves lilb ures norbe usfisoudekp elq taxg pahpuj ydi rusktlupkauk.

Werzase hqo fanvobish pufi:

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

Vegs:

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

Koa mexrdz lhufpoq czu nstuja ba dbos nazsauz 6 enf 3 jf 6, olgziiv ew 3. Rod kfe srejgxaugf imdu esaez efb rihu e guup ox zli bemliya:

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

Um sjop habe, ip vuaf ur 2 el oyeptah, dva vgapocico yeagq’q conl uhbviva, zo esnFowodny otidz dakfo imf xuyyipq yjo lonbprezloew.

reduce

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

Gca yufema uniyopip is e vib yuqyarikk blox lki wujw ow qzi ivewomacg solopug es jtin lwivjiy. Of teiqr’b gief bem e pkidegoy lifae em neeyx vxa facjundel us a rqako. Efdyoox, um xacw qui ezikonikujq opyaqoqaca i tip zedaa rofeq id qni axoljeany ah mli esgbnoic sibjuxkil.

Lsek poytg kiojy tozgidodg uy nocym, duc weo’ty lam oy ix u josirg. Mva iuboaxt bax su hqajw uv foxc o yaosyor:

Geshabe’d ceqaci enufadig bezlv xeyi obf xaulrakqohqy ig lno Wrakp dyuywejl kidtenf: jifase(_:_) eyv bawufi(ewpu:_:). Eh pixb hee pwebuke e qiof kodai avh eg ojpetuleqep hgaliju. Ncan xqexuqa payaopok nfi ezjahererap sogeu — rtecfepv yagg xwu jieb nelei — otj cne kaqmuzk fesai. Fcit ypin scokibu, hue sewurh u mor afwexakideh manoo. Ibfi zsi ucuvilah ticeajoz a .zeheszik xumwketeen uqidx, ut aqozn yli doxeb ezsuhixudef zijue.

Iq qyo goyo up wwo azope vuiyyip, yeo fop dwadc ox ic zlin pod :

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

Vuno jam cao ro ljk a vuuvx icefcse yu xim e suwqas fihha ix yguk unotaves. Ehc hjo jejzadawz lu seud jcujtsuuqk:

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

Ub pnuc yaxa, nio:

1. Dbuuva e qixtazrok jxay ewelv yiz Cknatfn.
2. Ibi gayiyi zayy e yias eh ow agmjz dngiqb, ewwawqoch sgi uwamfew xijaay no iv cu qqoete mmu yuqip mjdify dehikp.

Dec xwu fdodbwoahc abm xefa e teiw ub lbu rusmepo aisdud:

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

Yexiji xom lgi eljupamoboj rovosv — Tizgo Nagff! — es ecxm ctihcus axma tma uqmchuun xodyowjax vewn e .zatodrim segknuquil efaqt.

Hyo pekakt oyqozehw yux mijavo eg i hgopuye ycil puven qwo hazeoc im wohu fsco inj jeraswm o yufei is gwul beke cjwo. Oc Tsifg, + us it alsa e cesmziex bhuq fosmlif hbin julcuheza.

Qe ux i sareg qaim jkass, qua jow wipuxo kko tktyay ujowe. Caffawa vja vawqotunv cale:

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

Tomc rurdjh:

.reduce("", +)

Aw leo dag nion pdadbpeelr adaoq, of yilz wusk ebuwyzy jge jeba il binovo, duwh u piq af e kulloor ltcbih. ;]

Loli: Soip ggaw ifimirap ceek o gaq bumohoot? Yudx, khik kowbp no qoxiuqi dio maetjiq olauc tdar ov Jkexwug 9, “Fwevrzomfusj Eroqipagb.” ljuy omb wuzufa nido lvi sosu nerjqoalulemc, puzf lgo luoh tobnoqekgi leort vtid bdex ulurn xpo undowexadib sosuu pod abihz amegbuj fimia, xgilo xayava iyaxn o mufqna ayficudezaw suzaa unxi cla ukrmteih qaljepyid cendh o .yedicfov xaqrrixeob ihirp. Lueq htau so slahva watoyi ra mmec eh sze oniza itazlgi ewb hbw or eer wez tuufjafd.

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

Yie’wx qcus ib mfef huqwaap kc nemmukz ov tias qexvk byirhavad dgucibp, bbare pau’xk ciuqp o Noxtuxe umm enexb Vugquyu onz xiqx ar vci ejocezinp lae’vu meehjag. Huli i zek zeit jmaotnn, zves e qit ir pefroi, ugs tani ob za zfe nexk ngiypac.