Triển khai mặc định giao thức gọi từ phương thức thông thường

Tôi tự hỏi liệu có thể đạt được điều đó không.
Tôi có một Sân chơi như thế này:

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

Tôi có thể cung cấp triển khai mặc định trong extensionnhưng nếu Barcần mọi thứ có trong triển khai mặc định cộng với những thứ bổ sung?
Nó bằng cách nào đó tương tự như việc gọi super.các phương thức trong classes để đáp ứng yêu cầu thực hiện mọi thuộc tính, v.v. nhưng tôi không thấy có khả năng đạt được điều tương tự với structs.

Tôi không biết nếu bạn vẫn đang tìm kiếm câu trả lời cho điều này, nhưng cách thực hiện là xóa hàm khỏi định nghĩa giao thức, truyền đối tượng của bạn tới Foovà sau đó gọi phương thức trên đó:

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"

Vì một số lý do, nó chỉ hoạt động nếu hàm không được khai báo như một phần của giao thức, nhưng được định nghĩa trong phần mở rộng của giao thức. Đi tìm hình. Nhưng nó hoạt động.

Chà, bạn có thể tạo một kiểu lồng nhau phù hợp với giao thức, khởi tạo nó và gọi phương thức trên kiểu đó (không quan trọng là bạn không thể truy cập dữ liệu kiểu của mình vì việc triển khai bên trong tiện ích mở rộng giao thức không thể tham chiếu đến nó). Nhưng đó không phải là một giải pháp mà tôi gọi là thanh lịch.

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

Cảm ơn vì bài đăng! Nếu bạn đặt định nghĩa hàm trong giao thức thì khi đối tượng được truyền làm giao thức, nó chỉ nhìn thấy phiên bản của đối tượng của hàm và vì bạn đang gọi nó bên trong chính nó nên bạn sẽ nhận được địa chỉ mới của Apple ...

Tôi đã thử một phiên bản như thế này:

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

Điều này cho kết quả là:

Structure Version
Extension Version

Trong trường hợp giao thức của bạn có associatedTypehoặc Selfyêu cầu, thì quá trình truyền sẽ không hoạt động. Để giải quyết vấn đề này, hãy tạo một triển khai mặc định "bóng" mà cả triển khai mặc định thông thường và kiểu tuân thủ đều có thể gọi.

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

bạn nghĩ gì về cách khắc phục điều này?

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