¿Existe una forma estándar de hacer una "función virtual pura" en Swift, es decir. uno que debe ser anulado por cada subclase, y que, si no es así, causa un error de tiempo de compilación?

Tienes dos opciones:

1. Utilice un protocolo

Definir la superclase como Protocolo en lugar de Clase

Ventaja : compile la verificación de tiempo para ver si cada "subclase" (no una subclase real) implementa los métodos requeridos

Desventaja : la "superclase" (protocolo) no puede implementar métodos o propiedades

2. Afirmar en la super versión del método

Ejemplo:

class SuperClass {
    func someFunc() {
        fatalError("Must Override")
    }
}

class Subclass : SuperClass {
    override func someFunc() {
    }
}

Ventaja : puede implementar métodos y propiedades en superclase

Desventaja : Sin verificación de tiempo de compilación

Lo siguiente permite heredar de una clase y también tener la verificación del tiempo de compilación del protocolo :)

protocol ViewControllerProtocol {
    func setupViews()
    func setupConstraints()
}

typealias ViewController = ViewControllerClass & ViewControllerProtocol

class ViewControllerClass : UIViewController {

    override func viewDidLoad() {
        self.setup()
    }

    func setup() {
        guard let controller = self as? ViewController else {
            return
        }

        controller.setupViews()
        controller.setupConstraints()
    }

    //.... and implement methods related to UIViewController at will

}

class SubClass : ViewController {

    //-- in case these aren't here... an error will be presented
    func setupViews() { ... }
    func setupConstraints() { ... }

}

No hay soporte para funciones virtuales / clases abstractas, pero probablemente podría usar un protocolo para la mayoría de los casos:

protocol SomeProtocol {
    func someMethod()
}

class SomeClass: SomeProtocol {
    func someMethod() {}
}

Si SomeClass no implementa someMethod, obtendrá este error de tiempo de compilación:

error: type 'SomeClass' does not conform to protocol 'SomeProtocol'

Otra solución, si no tiene demasiados métodos "virtuales", es hacer que la subclase pase las "implementaciones" al constructor de la clase base como objetos de función:

class MyVirtual {

    // 'Implementation' provided by subclass
    let fooImpl: (() -> String)

    // Delegates to 'implementation' provided by subclass
    func foo() -> String {
        return fooImpl()
    }

    init(fooImpl: (() -> String)) {
        self.fooImpl = fooImpl
    }
}

class MyImpl: MyVirtual {

    // 'Implementation' for super.foo()
    func myFoo() -> String {
        return "I am foo"
    }

    init() {
        // pass the 'implementation' to the superclass
        super.init(myFoo)
    }
}

Puede usar protocolo frente a aserción como se sugiere en la respuesta aquí de drewag. Sin embargo, falta un ejemplo del protocolo. Estoy cubriendo aquí,

Protocolo

protocol SomeProtocol {
    func someMethod()
}

class SomeClass: SomeProtocol {
    func someMethod() {}
}

Ahora se requiere que todas las subclases implementen el protocolo que se verifica en tiempo de compilación. Si SomeClass no implementa someMethod, obtendrá este error de tiempo de compilación:

error: el tipo 'SomeClass' no se ajusta al protocolo 'SomeProtocol'

Nota: esto solo funciona para la clase superior que implementa el protocolo. Cualquier subclase puede ignorar alegremente los requisitos del protocolo. - como se ha comentado pormemmons

Afirmación

class SuperClass {
    func someFunc() {
        fatalError("Must Override")
    }
}

class Subclass : SuperClass {
    override func someFunc() {
    }
}

Sin embargo, la aserción solo funcionará en tiempo de ejecución.

Siendo nuevo en el desarrollo de iOS, no estoy del todo seguro de cuándo se implementó, pero una forma de obtener lo mejor de ambos mundos es implementar una extensión para un protocolo:

protocol ThingsToDo {
    func doThingOne()
}

extension ThingsToDo {
    func doThingTwo() { /* Define code here */}
}

class Person: ThingsToDo {
    func doThingOne() {
        // Already defined in extension
        doThingTwo()
        // Rest of code
    }
}

La extensión es lo que le permite tener el valor predeterminado para una función, mientras que la función en el protocolo regular aún proporciona un error de tiempo de compilación si no está definida