Abstract methods in Swift?

How do you define abstract methods, while implementing others?

The "swifty" way of achieving this is combining protocols and extensions, sometimes also typealiases. For data, you are going to define abstract properties in your protocol, then re-define them in a concrete class, then unite all that using a typealias and the & operator:

protocol BaseAbstract: class {
    var data: String { get set }
    func abstractMethod()
    func concreteMethod()
}


extension BaseAbstract {
    // Define your concrete methods that use the abstract part of the protocol, e.g.:
    func concreteMethod() {
        if !data.isEmpty {
            abstractMethod()
        }
    }
}


class BaseImpl {
    // This is required since we can't define properties in extensions.
    // Therefore, we define a class with a concrete property and then 
    // unite it with the protocol above in the typealias below.
    var data: String = "Hello, concrete!"
}


typealias Base = BaseAbstract & BaseImpl // et voila, `Base` is now ready to be subclassed


class Subclass: Base {
    func abstractMethod() { // enforced by the compiler
    }
}

(It can get tricker if you have generics in this scenario. Currently trying to figure it out.)

There is no Abstract concept in Swift. But we can achieve that scenario by using Inheritance concept like the code below:

class ParentVC:UIViewController {

    func loadInformation() {
    }
}

class ChildVC:ParentVC {

    // This is an Abstract Method
    override func loadInformation() { 
    }
}