Виклик реалізації протоколу за замовчуванням із звичайного методу

Цікаво, чи можливо досягти такого?
У мене є такий дитячий майданчик:

protocol Foo {
    func testPrint()
}

extension Foo {
    func testPrint() {
        print("Protocol extension call")
    }
}

struct Bar: Foo {
    func testPrint() {
        // Calling self or super go call default implementation
        self.testPrint()
        print("Call from struct")
    }
}


let sth = Bar()
sth.testPrint()

Я можу надати реалізацію за замовчуванням, extensionале що, якщо Barпотрібно все, що є в реалізації за замовчуванням, а також додаткові речі?
Це якось схоже на виклик super.методів в classes для виконання вимоги щодо реалізації кожного властивості тощо, але я не бачу можливості досягти того самого за допомогою structs.

Я не знаю, чи все ще ви шукаєте відповідь на це, але спосіб це зробити - це вилучити функцію з визначення протоколу, передати свій об’єкт, Fooа потім викликати на ньому метод:

protocol Foo { 
    // func testPrint() <- comment this out or remove it
}

extension Foo {
    func testPrint() {
        print("Protocol extension call")
    }
}

struct Bar: Foo {
    func testPrint() {
        print("Call from struct")
        (self as Foo).testPrint() // <- cast to Foo and you'll get the  default
                                  //    function defined in the extension
    }
}

Bar().testPrint()

// Output:    "Call from struct"
//            "Protocol extension call"

З якихось причин вона працює лише в тому випадку, якщо функція не оголошена як частина протоколу, а визначена у розширенні протоколу. Піди розберися. Але це працює.

Ну, ви можете створити вкладений тип, що відповідає протоколу, створити його інстанцію і викликати метод на цьому (неважливо, що ви не можете отримати доступ до даних вашого типу, оскільки реалізація всередині розширення протоколу не може посилатися на нього в будь-якому випадку). Але це не рішення, яке я назвав би елегантним.

struct Bar: Foo {
    func testPrint() {
        // Calling default implementation
        struct Dummy : Foo {}
        let dummy = Dummy()
        dummy.testPrint()
        print("Call from struct")
    }
}

Дякую за допис! Якщо ви помістите визначення функції в протокол, тоді, коли об'єкт буде відлитий як протокол, він бачить лише версію функції об'єкта, і оскільки ви викликаєте його всередину себе, ви отримуєте нову адресу Apple ...

Я спробував таку версію:

import UIKit
protocol MyProc
{
}

protocol MyFuncProc
{
    func myFunc()
}

extension MyProc
{
    func myFunc()
    {
        print("Extension Version")
    }
}

struct MyStruct: MyProc, MyFuncProc
{
    func myFunc()
    {
        print("Structure Version")
        (self as MyProc).myFunc()
    }
}

(MyStruct() as MyFuncProc).myFunc()

Це дає результат:

Structure Version
Extension Version

У разі , якщо ваш протокол має associatedTypeабо Selfвимоги, то приведення не працюватиме. Щоб обійти це, створіть "тіньову" реалізацію за замовчуванням, яку можуть викликати як звичайна реалізація за замовчуванням, так і відповідний тип.

protocol Foo { 
    associatedType Bar
}

extension Foo {
    func testPrint() {
        defaultTestPrint()
    }
}

fileprivate extension Foo { // keep this as private as possible
    func defaultTestPrint() {
        // default implementation
    }
}

struct Bar: Foo {
    func testPrint() {
        // specialized implementation
        defaultTestPrint()
    }
}

що ви думаєте про такий спосіб виправити це?

protocol Foo {
    func testPrint()
}

extension Foo {
    func testPrint() {
        defaultTestPrint()
    }

    func defaultTestPrint() {
        print("Protocol extension call")
    }
}

struct Bar: Foo {
    func testPrint() {
        // Calling self or super go call default implementation
        defaultTestPrint()
        print("Call from struct")
    }
}


let sth = Bar()
sth.testPrint()

Я придумав рішення для цього.

Проблема

Коли у вас є реалізація за замовчуванням у розширенні, коли ви реалізуєте протокол до іншого класу / структури, ви реалізуєте цю реалізацію за замовчуванням, якщо реалізуєте метод. Це за задумом, так працюють протоколи

Рішення

• Створіть реалізацію вашого протоколу за замовчуванням і зробіть це властивістю вашого протоколу.
• Потім, коли ви реалізуєте цей протокол у класі, надайте реалізацію за замовчуванням за допомогою геттера
• Зателефонуйте за замовчуванням, коли вам потрібно.

Приклад

protocol Foo {
    var defaultImplementation: DefaultImpl? { get }
    func testPrint()
}

extension Foo {
    // Add default implementation
    var defaultImplementation: DefaultImpl? {
        get {
            return nil
        }
    }
}

struct DefaultImpl: Foo {
    func testPrint() {
        print("Foo")
    }
}


extension Foo {
    
    func testPrint() {
        defaultImplementation?.testPrint()
    }
}

struct Bar: Foo {
    
    var defaultImplementation: DefaultImpl? {
        get { return DefaultImpl() }
    }
    func testPrint() {
        if someCondition {
            defaultImplementation?.testPrint() // Prints "Foo"
        }
    }
}

struct Baz: Foo {
    func testPrint() {
        print("Baz")
    }
}


let bar = Bar()
bar.testPrint() // prints "Foo"

let baz = Baz()
baz.testPrint() // prints "Baz"

Недоліки

Ви втрачаєте необхідну помилку реалізації в структурі / класі, де ви реалізуєте цей протокол.