Extensiones con implementación por defecto y el peligro del despacho estático

Una extension sobre un protocolo es el mecanismo más productivo de Swift y también su trampa más silenciosa. Productivo, porque permite escribir una vez un algoritmo que todos los conformantes reciben gratis. Trampa, porque el método que escribes en la extensión puede comportarse de dos maneras radicalmente distintas según un detalle fácil de pasar por alto: si su firma aparece o no en la declaración del protocolo. En un caso se despacha dinámicamente y respeta la implementación del tipo; en el otro se resuelve en compilación y el tipo pierde la voz. El resultado son bugs que no lanzan errores: simplemente ejecutan el código equivocado.

Comportamiento regalado desde fuera

El protocolo declara el contrato; la extensión lo rellena. Todo tipo que conforme obtiene el cuerpo sin escribir nada.

protocol Reproductor {
    var duracion: Double { get }
    func reproducir()
}

extension Reproductor {
    func reproducir() {
        print("reproduciendo \(duracion) segundos")
    }
    var esLargo: Bool { duracion > 600 }
}

struct Podcast: Reproductor {
    let duracion: Double
    // no implementa reproducir: hereda el cuerpo de la extension
}

Podcast cumple el contrato aportando una sola propiedad. La extensión aporta el resto. Y como puede apoyarse en los requisitos —esLargo consulta duracion—, la capa por defecto es un algoritmo escrito en términos abstractos que se especializa para cada conformante.

Hay una asimetría deliberada en el ejemplo: reproducir está declarado en el protocolo y además tiene un cuerpo por defecto; esLargo solo existe en la extensión. Esa diferencia, que a la vista es de dos líneas, decide cómo se resolverá cada llamada.

La tabla de testigos y el despacho estático

Cuando un tipo conforma a un protocolo, el compilador construye una tabla de testigos (protocol witness table): una lista que asocia cada requisito declarado con la implementación concreta que ese tipo aporta. Al llamar a un requisito a través del protocolo, la llamada consulta la tabla en ejecución y encuentra la implementación real del tipo.

Un miembro que solo vive en la extensión no entra en esa tabla. No es un requisito, así que no hay nada que registrar. Su llamada se resuelve en compilación, según el tipo estático de la expresión.

protocol Formato {
    func cabecera() -> String        // requisito: entra en la tabla
}

extension Formato {
    func cabecera() -> String { "por defecto" }
    func pie() -> String { "pie por defecto" }   // solo extension
}

struct Informe: Formato {
    func cabecera() -> String { "cabecera de Informe" }
    func pie() -> String { "pie de Informe" }
}

let concreto = Informe()
let abstracto: Formato = Informe()

concreto.cabecera()   // cabecera de Informe
concreto.pie()        // pie de Informe
abstracto.cabecera()  // cabecera de Informe   <- tabla de testigos
abstracto.pie()       // pie por defecto       <- despacho estatico

Las dos últimas líneas son el corazón de la lección. El mismo objeto, la misma llamada, dos resultados. abstracto.pie() ejecuta el cuerpo de la extensión porque el compilador solo sabe que la variable es un Formato, y Formato no promete ningún pie.

flowchart TB
call[llamada a un miembro sobre un valor] --> q{esta la firma declarada en el protocolo}
q -->|si| wit[tabla de testigos]
q -->|no| est[despacho estatico por tipo estatico]
wit --> real[se ejecuta la implementacion del tipo concreto]
est --> ext[se ejecuta siempre el cuerpo de la extension]

Por qué existe esta regla

No es un descuido del diseño del lenguaje, sino una consecuencia del coste. La tabla de testigos añade una indirección por llamada; los miembros de extensión que nadie prometió pueden inlinearse y desaparecer. Swift optimiza por defecto lo que no forma parte del contrato, y reserva el despacho dinámico para lo que sí se prometió.

La lectura constructiva de esa regla es una guía de diseño precisa:

El bug tal como aparece en producción

El fallo casi nunca se presenta en un ejemplo de tres líneas. Se presenta así:

protocol Celda {
    var altura: Double { get }
}

extension Celda {
    var altura: Double { 44 }
    var accesible: Bool { false }        // solo extension: trampa
}

struct CeldaTitulo: Celda {
    var altura: Double { 88 }
    var accesible: Bool { true }
}

func configurar(_ celdas: [any Celda]) {
    for c in celdas {
        print(c.altura, c.accesible)     // 88.0 false
    }
}

altura responde correctamente porque es un requisito; accesible devuelve false para una celda que declaró true. La función que rompe el programa no contiene ningún error: el error está en la declaración del protocolo, a cien líneas y dos archivos de distancia, y consiste en algo que no se escribió. Mover la firma de accesible al protocol arregla el comportamiento sin tocar ni el conformante ni el bucle.