Op welk moment en onder welke voorwaarden begint…

Method dispatch in Swift bepaalt welke code wordt uitgevoerd bij het aanroepen van een methode van een object. De keuze van het dispatch-type gebeurt op het moment van compilatie van de Swift-code.

Er zijn drie hoofdtypen dispatch in Swift:

Directe dispatch (Direct Dispatch):
- De snelste.
- Het adres van de functie is bekend tijdens compilatie.
- Wordt standaard toegepast op:
  - struct en enum (omdat ze geen class-erfenis ondersteunen).
  - final methoden van klassen.
  - private methoden van klassen (internal en public ondersteunen geen directe dispatch).
  - Globale functies.
  - Statische methoden.
  - Extensies.
Tabeldispatch (Table Dispatch):
- Gebruikt voor class, wanneer polymorfisme en erfenis nodig zijn.
- Het adres van de specifieke implementatie van de methode wordt tijdens runtime bepaald met behulp van de virtuele methodentabel (vtable - Virtual Table).
- Elke klasse heeft zijn eigen vtable, met pointers naar methodenimplementaties.
- Ondersteunt erfenis en overschrijven van methoden.
```
class Animal { // Toepassing van Table Dispatch
    func speak() {
        print("Onbekend geluid")
    }
}

class Dog: Animal { // Overschrijving, gebruikt vtable
    override func speak() {
        print("Woef")
    }
}
```
Witness Table Dispatch:
- Gebruikt voor protocollen (protocol).
- Vergelijkbaar met table dispatch, maar gebruikt een witness table om de implementatie van de protocolmethode voor een specifiek type te vinden.
- Maakt polymorfisme met protocollen mogelijk.
```
protocol Speakable { // Toepassing van Witness Table Dispatch
    func speak()
}

struct Cat: Speakable { // Implementatie van protocol
    func speak() {
        print("Miauw")
    }
}
```

Invloedrijke voorwaarden voor de keuze:

Datatype: struct, enum, class, protocol.
Toegangsmodifiers: final, private, internal, public.
Erfenis: Mogelijkheid tot overschrijven van methoden.
Protocolconformiteit: Implementatie van protocolmethoden.
Aanroepcontext: Aanroep via een concreet type of via een protocol/basisklasse.

De Swift-compiler probeert waar mogelijk direct dispatch te gebruiken voor optimalisatie, maar schakelt over naar table of witness table dispatch indien nodig om polymorfisme en erfenis te ondersteunen. Het expliciet markeren van methoden als final of private dwingt het gebruik van direct dispatch af.

Op welk moment en onder welke voorwaarden begint dispatching in Swift te werken?