An attempt to a protocol-oriented MVP implementation in Swift

mvp_protocol_oriented.swift

import Foundation

protocol BaseController {
    associatedtype SomePresenter : BasePresenter

    func getPresenter() -> SomePresenter

    func doFromBaseController()
}

extension BaseController {

    func getPresenter() -> SomePresenter {
        preconditionFailure()
    }

    func doSomethingOnlyTheBaseControllerKnows() {
        // do something
    }

    func tryActionsFromBasePresenter() {
        getPresenter().somethingOnlyTheBasePresenterDoes()
    }

}

protocol BaseControllerHandler {
    func doFromBaseController()
}

extension BaseControllerHandler where Self : BaseController {
    func doFromBaseController() {
        // the implementation goes here
        self.doSomethingOnlyTheBaseControllerKnows()
    }
}

class ControllerHandler : BaseControllerHandler, BaseController {
    typealias SomePresenter = CustomPresenter

    // Add here the stubs for the methods you want to expose to the presenter.
    func doFromConcreteController() {
        preconditionFailure()
    }

}

class CustomController: ControllerHandler {

    lazy var presenter = CustomPresenter(handler: self)

    override func doFromConcreteController() {
        // doSomething
    }

    func tryActionsFromCustomPresenter() {
        self.presenter.somethingOnlyTheBasePresenterDoes()
        self.presenter.doFromCustomPresenter()
    }

    func getPresenter() -> SomePresenter {
        return self.presenter
    }

}


protocol BasePresenter {
    associatedtype SomeControllerHandler : BaseControllerHandler

    func getControllerHandler() -> SomeControllerHandler
}

extension BasePresenter {

    func somethingOnlyTheBasePresenterDoes() {
        // do something
    }

    func tryActionsFromBaseHandler() {
        getControllerHandler().doFromBaseController()
    }
}

struct CustomPresenter: BasePresenter {

    typealias SomeControllerHandler = ControllerHandler

    let handler : SomeControllerHandler

    init(handler : SomeControllerHandler ) {
        self.handler = handler;
    }

    func getControllerHandler() -> SomeControllerHandler {
        return self.handler
    }

    func doFromCustomPresenter() {
        // do something
    }

    func tryActionsFromControllerHandler() {
        self.handler.doFromConcreteController()
        self.handler.doFromBaseController()
    }

}