Antwoord

Pattern matching voor tuples in Swift maakt het mogelijk om waarden gemakkelijk te vergelijken en uit te pakken. In een switch kunnen tuples direct in het patroon worden afgebroken:

let point = (x: 0, y: 2)
switch point {
  case (0, 0):
    print("Op de oorsprong")
  case (0, let y):
    print("x = 0, y = \(y)")
  case let (x, y) where x == y:
    print("x is gelijk aan y")
  default:
    print("Een ander punt")
}

Aandachtspunten:

• Het aantal en de volgorde van elementen moeten overeenkomen met de tuple.
• Possible binding en guard-expressies werken zoals bij gewone variabelen.
• Exhaustiveness check is alleen mogelijk voor tuples van waarden waarvoor een volledig bereik is gedefinieerd.

Vraag met een verrassing

Kan je switch-case gebruiken om een tuple van het type (String, Int) te vergelijken met een case-patroon van verschillende types, bijvoorbeeld case (let a, let b):?

Vaak wordt gezegd dat het kan, maar het is belangrijk — de types van de variabelen in het patroon moeten strikt overeenkomen met het type van de tuple.

let pair = ("abc", 5)
switch pair {
case (let text, let number):
   print("String: \(text), nummer: \(number)") // Ok
case (let x, let y) where x == y:
   print("Fout")  // Fout: Binaire operator '==' kan niet worden toegepast op operandtypes 'String' en 'Int'
default: break
}

Als de types niet overeenkomen, geeft de compiler een foutmelding tijdens het compileren.

Voorbeelden van echte fouten door onwetendheid over de nuances van het onderwerp

---

Verhaal

In een project probeerden ze switch-case te gebruiken voor het ontleden van een serverantwoord als tuple, zonder rekening te houden met mogelijke nil-waarden. Dit leidde ertoe dat geen enkele case overeenkwam, en de default werd uitgevoerd, terwijl andere logica was voorzien.

---

Verhaal

Type mismatch: in de functie ontving de handler de tuple (Int, String), maar het werd geprobeerd uit te pakken als (String, Int). Resultaat — crash tijdens het compileren en verloren tijd bij het zoeken naar de oorzaak.

---

Verhaal

Gebruikten guard voor het uitpakken van de tuple van het resultaat zonder rekening te houden met de mogelijkheid van negatieve waarden, hoewel de verwerking alleen was voorzien voor positieve getallen. Uiteindelijk werden valide cases genegeerd, wat een probleem bleek te zijn in de business logica.