Existe uma maneira padrão de fazer uma "função virtual pura" em Swift, ou seja. um que deve ser substituído por cada subclasse e que, se não for, causa um erro de tempo de compilação?

Você tem duas opções:

1. Use um protocolo

Defina a superclasse como um protocolo em vez de uma classe

Pro : verificar o tempo de compilação para ver se cada "subclasse" (não uma subclasse real) implementa os métodos necessários

Contra : A "superclasse" (protocolo) não pode implementar métodos ou propriedades

2. Afirmar na super versão do método

Exemplo:

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

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

Pro : pode implementar métodos e propriedades na superclasse

Contra : Sem verificação de tempo de compilação

O seguinte permite herdar de uma classe e também ter a verificação do tempo de compilação do 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() { ... }

}

Não há suporte para classes abstratas / funções virtuais, mas você provavelmente poderia usar um protocolo para a maioria dos casos:

protocol SomeProtocol {
    func someMethod()
}

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

Se SomeClass não implementar someMethod, você receberá este erro de tempo de compilação:

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

Outra solução alternativa, se você não tiver muitos métodos "virtuais", é fazer com que a subclasse passe as "implementações" para o construtor da classe base como objetos de função:

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)
    }
}

Você pode usar protocolo versus asserção conforme sugerido na resposta aqui por drewag. No entanto, falta um exemplo para o protocolo. Estou cobrindo aqui,

Protocolo

protocol SomeProtocol {
    func someMethod()
}

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

Agora, todas as subclasses são necessárias para implementar o protocolo que é verificado em tempo de compilação. Se SomeClass não implementar someMethod, você receberá este erro de tempo de compilação:

erro: o tipo 'SomeClass' não está em conformidade com o protocolo 'SomeProtocol'

Observação: isso só funciona para a classe superior que implementa o protocolo. Qualquer subclasse pode ignorar alegremente os requisitos do protocolo. - como comentado pormemmons

Afirmação

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

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

No entanto, a asserção funcionará apenas em tempo de execução.

Sendo novo no desenvolvimento de iOS, não tenho certeza de quando isso foi implementado, mas uma maneira de obter o melhor dos dois mundos é implementar uma extensão para um 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
    }
}

A extensãoéo que lhe permite ter o valor padrão para uma função enquanto a função no protocolo regular ainda fornece um erro de tempo de compilação se não for definido