Normal yöntemden protokol varsayılan uygulamasını çağırma

Böyle bir şeyi başarmanın mümkün olup olmadığını merak ediyorum.
Bunun gibi bir Oyun Alanım var:

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

İçinde varsayılan bir uygulama sağlayabilirim, extensionancak ya varsayılan uygulamadaki Barher şeye ve ek şeylere ihtiyaç duyuyorsa?
Bu bir şekilde her özelliği uygulama vb. Gereksinimlerini yerine getirmek için super.yöntem çağırmaya benzer, classancak aynı şeyi başarma imkanı görmüyorum structs.

Hala buna bir cevap arıyor musunuz bilmiyorum, ancak bunu yapmanın yolu, işlevi protokol tanımından kaldırmak, nesnenizi atamak Foove ardından yöntemi çağırmaktır:

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"

Bazı nedenlerden dolayı, yalnızca işlev protokolün bir parçası olarak bildirilmemişse, ancak protokolün bir uzantısı olarak tanımlanmışsa çalışır. Şekle gidin. Ama işe yarıyor.

Pekala, protokole uygun iç içe geçmiş bir tür oluşturabilir, onu başlatabilir ve yöntemi ondan çağırabilirsiniz (protokol uzantısının içindeki uygulama buna zaten başvuruda bulunamayacağı için türünüzün verilerine erişememeniz önemli değildir). Ama zarif diyebileceğim bir çözüm değil.

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

Gönderi için teşekkürler! İşlev tanımını protokole koyarsanız, nesne protokol olarak dönüştürüldüğünde, yalnızca nesnenin işlevin sürümünü görür ve siz onu kendi içinde çağırdığınız için Apple'ın yeni adresini alırsınız ...

Bunun gibi bir versiyon denedim:

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

Bu bir çıktı verir:

Structure Version
Extension Version

Protokolünüzün associatedTypeveya Selfgereksinimlerin olması durumunda , döküm çalışmayacaktır. Bu sorunu çözmek için, hem normal varsayılan uygulamanın hem de uygun türün çağırabileceği bir "gölge" varsayılan uygulaması oluşturun.

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

Bunu düzeltmenin böyle bir yolu hakkında ne düşünüyorsun?

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

Bunun için bir çözüm buldum.

Konu

Bir uzantıda varsayılan bir uygulamaya sahip olduğunuzda, protokolü başka bir sınıfa / yapıya uyguladığınızda, yöntemi uygularsanız bu varsayılan uygulamayı kaybedersiniz. Bu tasarım gereğidir, protokoller böyle çalışır

Çözüm

• Protokolünüz için bir Varsayılan Uygulama oluşturun ve bunu protokolünüzün bir özelliği yapın.
• Daha sonra bu protokolü bir sınıfta uyguladığınızda, varsayılan uygulamanızı bir alıcı ile sağlayın
• İhtiyaç duyduğunuzda varsayılan uygulamayı arayın.

Misal

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"

Dezavantajlar

Bu protokolü uyguladığınız yapı / sınıfta gerekli uygulama hatasını kaybedersiniz.