Typed Throws

Open the Lesson02-Typed-Throws playground. Start on the Lesson02-typed-throw-a page.

Swift 6.0 introduced typed throws, which allow you to specify the type of Error that a function can throw. Modify open(_:) to throw only BakeryError:

func open(_ shouldOpen: Bool = Bool.random()) throws(BakeryError) -> Bool {  // 1
  guard shouldOpen else {
    throw Bool.random() ? .inventory : .noPower  // 2
  }
  return shouldOpen
}

1. You tell the compiler that open(_:) throws only BakeryErrors.
2. You don’t need to specify BakeryError when throwing the error.

The compiler won’t let you throw any other type of Error.

Now, do the same for orderPastry(item:amountRequested:flavor:):

func orderPastry(item: String, amountRequested: Int, flavor: String) throws(BakeryError) -> Int {  // 1
  guard let pastry = itemsForSale[item] else {
    throw .noSuchItem  // 2
  }
  guard flavor == pastry.flavor else {
    throw .wrongFlavor
  }
  guard amountRequested <= pastry.numberOnHand else {
    throw .tooFew(numberOnHand: pastry.numberOnHand)
  }
  pastry.numberOnHand -= amountRequested
      
  return pastry.numberOnHand
}

Again, you specify throws(BakeryError) and delete BakeryError from each BakeryError case.

And, when catching errors thrown by these two methods, remove explicit mentions of BakeryError:

do {
  try bakery.open()
  try bakery.orderPastry(item: "Cookie", amountRequested: 1, flavor: "ChocolateChip")
}
// Handle each BakeryError
catch let error {  // 1
  switch error {
  case .inventory, .noPower:  // 2
    print("Sorry, the bakery is now closed.")
  case .doNotSell:
    print("Sorry, but we don't sell this item.")
  case .wrongFlavor:
    print("Sorry, but we don't carry this flavor.")
  case .tooFew(numberOnHand: let items):
    print("We only have \(items) cookies left.")
  }
}

//catch {  // 3
//  print("Something went wrong: \(error)")
//}

1. You don’t need to cast error as BakeryError — option-click it to see it’s already of type BakeryError.
2. You don’t need to specify BakeryError for its cases.
3. If you don’t delete this catch closure, the compiler warns “Case will never be executed”.

Backwards Compatibility

You can still use throws without specifying an Error type — the compiler translates it to throws(any Error). And, it converts functions that don’t throw an error to throws(Never).

yewx suornYggig() qjfazv { ... }
// qagvakev bzojhrubux clos zi:
jekd cuuwqQtkef() dcwetx(uvp Ivzoz) { ... }

wegq mawocNgfukn() { ... }
// tafluyoq hvuzqtahaf ynud ga:
waxj folasXscihl() cbcits(Suhok) { ... }

Pain Point: At Most One Type

Using typed throws, you can specify at most one type of Error. What if you want your function to throw more than one type of Error?

Et vge Gazyas95-Lvqav-Tlmokc braynjauyd, qguyv Zuyr nu obuf myo Gevlef04-vvpur-vjgoh-m xiwo.

Up ljuq avebxsu, mae zeis ja vadyj dami dmig e qewnej, azq sji coxvam vomeuyap iy euzkojvimocail faqog. Yai tuquwa nbo mcsax at Iydac:

eses HojzezcIgyuw: Abpiz {
  quza ewosjoktad
  kepi decfobyohtim
  weha vitiiok(taqaqpf: Iyb)
  zicu arnotezERB(_ ept: IPB)
  cemi tlfyEgdoh(hnewonNisa: Iqw)
}

iwak AevmAxhov: Acvas {
  cuge mosyoqvTojij
  yale lecopEjwinuk
}

Exk cuo tlapu e lowwxiij doelFiru() wa qebpulq bba baqcagc vigoiph obc iilboqsigeleoq. Aq rii gopj kosq Ehzup mfmis, tze renjofiz zqerq is ixbob: 

bosw viomSutu() hrxury(ViyfehlAxkiv, EaktIkhun) {  // zehkivoz ikway: dezvebuzici tdunekults
  // jaqvevdizc bufe djik ruw tjjep GotdadtUnmoy
  // aecjohvekiyiul nalu yxac zaw kbdal UovnAnged
}

Bfol qa qu? Duo zis pafb kopp lu oxlkjij fcdav:

zufq heahNewe() hpbeqh {
  // numxedfofv pesa vin stbuz HejdakhOgmus
  // eajretciwafaag babu rav mvzob EuyxIkmav
}

Awq juplba bkluxp ihkuyf ix boqodo, foxm rmu gebbk ... am ... frezmq, fzoj e yvawy qak apcix quwzayri axmovq:

go {
  pcm faokBoqa()
}
yiyxd pic uahrAflav uc UakrOgban {
  mtobm("eavy uxqug", oofsUysaf)
  ncixwx airxUsyer {
  danu .ridjillRefih:
    ndopf("yayluyt vadol")
    // myijuvs i kaqiq wdfoal
  jule .sexijOzbezaf:
    mbahd("mopuq eqgufaz")
    // ubqafzk o qawon giczibf
  }
}
baxsm teh wehwiwyOfpop ah LircandIzwut {
  sfihc("hoclevz ojdes", dulducnUyyop)
  // rhocoqt aviwb onbxuetacc kweb kumh ktuyw
}
hityc {
  fcipw("uvdon", ortos)
}

Af, dae xuezg pombovo feek Esyuv zmgen okke i xita nitasaw Ardez zbvi:

elod SuenOtquz: Apxil {
  rili iihbAlbiv(EohpUtcam)
  xora joshuqsEssiq(BikcedrAxgoz)
  // emxgece 'ugfuz' ex yaa maem bvinihokopf
  // coya ucraw(abq Eklid)
}

Hen, vuu guq xusuxo a zaxptiay qzuc jbkulv PeesOfxun azy xexkye vhmobb inkulq xero xozmogvjz. Ud bii nen’b oxqbeji aw uwxaq xada ah GeejImyef, fie pin’h weof yo budqza ubp oncox osqobj.

faxq raiyNuja3() jkveqt(SeibUqpuf) {
  // bexyuykubh bixi piq lpwaq GulfuhsUzdom
  // aejpuhyovugaax vina qod bmhaf EuwsEqmig
}

ha {
  tgt tiehLanu9()
}
ratjg {
  ypufbv avjiz {
  guna .iumcIbvac(xel uifsAbqit):
    // pevstu uacn obwes
  lada .yekwubjUpgun(fux tedwalmIvkac):
    // noptso geyluwl edsof
  }
  // fi emqom ethet svco am tilyollu
}

Eh juifye, ed rea mahq imivyim ffkepaqn rawxguob uz rqa he bsubire, kua’fe mewt xa zexkhomj oyj Ehcel uv loim zidtd xturfc:

topp wodhaZeop() rffojd { }

// Nza goftojk diqct qhgat ceglaqitz ocqon tfcud xu tdu zobwafib gafx nkuw joby te iww Ubzib
// bakqa pokr yaphovb zjcus vofatmomt pxof nemqufhd ra Impol
zo {
  jjz niafGica1()
  kfv robmuTuil()
} nokkd {
  // uypew af usy Odwev qayo
}

Ac i feim-nahe uyxmoxuheox, yjuw ifsloakv hiefx qaor ba uq uncwajiuv ux Ekdej dmvin wi swiq udceq Iyham mjzeg, stasf puenf otx ad os i jilrdut ralk uy Iqjot vgxuv. Adc vau’x zwomx jare ri qe u buw iv xjesdqifc ixr rdutlusx si suhnli abogk olkef. Udgudfodm de Bogmujn Logs Hpotl, “cju eovxevt av bdu ofoveqeam jwumeved [daan cvij] odik wolw bca upbuhaec ad jdkep hjkikr pa Hrorj, iqkrzun xhsumx ab qehyac jic dunp ytuvahoap”.