In quale momento e sotto quali condizioni inizia a…

La dispatch dei metodi (method dispatch) in Swift determina quale codice verrà eseguito quando si chiama un metodo di un oggetto. La scelta del tipo di dispatch avviene in momento di compilazione del codice Swift.

Esistono tre principali tipi di dispatch in Swift:

Dispatch diretto (Direct Dispatch):
- Il più veloce.
- L'indirizzo della funzione è noto durante la compilazione.
- Si applica di default a:
  - struct e enum (poiché non supportano l'ereditarietà delle classi).
  - Metodi final di classi.
  - Metodi private di classi (internal e public non supportano il dispatch diretto).
  - Funzioni globali.
  - Metodi statici.
  - Estensioni.
Dispatch tramite tabella (Table Dispatch):
- Usato per class, quando sono richiesti polimorfismo e ereditarietà.
- L'indirizzo dell'implementazione concreta del metodo viene determinato in fase di esecuzione (runtime) usando la tabella dei metodi virtuali (vtable - Virtual Table).
- Ogni classe ha la propria vtable, contenente puntatori alle implementazioni dei metodi.
- Supporta ereditarietà e override dei metodi.
```
class Animal { // Si applica il Table Dispatch
    func speak() {
        print("Suono sconosciuto")
    }
}

class Dog: Animal { // Override, usa vtable
    override func speak() {
        print("Bau")
    }
}
```
Dispatch tramite tabella dei testimoni (Witness Table Dispatch):
- Usato per i protocolli (protocol).
- Simile al dispatch tramite tabella, ma utilizza una tabella di testimoni (witness table) per trovare l'implementazione del metodo del protocollo per un tipo specifico.
- Permette il polimorfismo con i protocolli.
```
protocol Speakable { // Si applica il Witness Table Dispatch
    func speak()
}

struct Cat: Speakable { // Implementazione del protocollo
    func speak() {
        print("Miao")
    }
}
```

Condizioni che influenzano la scelta:

Tipo di dato: struct, enum, class, protocol.
Modificatori di accesso: final, private, internal, public.
Ereditarietà: Capacità di sovrascrivere i metodi.
Conformità ai protocolli: Implementazione dei metodi del protocollo.
Contesto di chiamata: Chiamata tramite un tipo concreto o tramite un protocollo/classe base.

Il compilatore Swift cerca di usare il dispatch diretto ove possibile per ottimizzare le prestazioni, ma se necessario, passa al dispatch tramite tabella o tramite tabella dei testimoni per supportare il polimorfismo e l'ereditarietà. La marcatura esplicita dei metodi come final o private permette di forzare l'uso del dispatch diretto.

In quale momento e sotto quali condizioni inizia a funzionare il dispatching in Swift?