Функция протокола возвращая собственную личность

С Swift 2, мы можем использовать расширения протокола для этого.

protocol Copyable {
    init(copy:Self)
}

extension Copyable {
    func copy() -> Self {
        return Self.init(copy: self)
    }
}

на самом деле, есть трюк, который позволяет легко возвращение Self при необходимости по протоколу (суть):

/// Cast the argument to the infered function return type.
func autocast<T>(some: Any) -> T? {
    return some as? T
}

protocol Foo {
    static func foo() -> Self
}

class Vehicle: Foo {
    class func foo() -> Self {
        return autocast(Vehicle())!
    }
}

class Tractor: Vehicle {
    override class func foo() -> Self {
        return autocast(Tractor())!
    }
}

func typeName(some: Any) -> String {
    return (some is Any.Type) ? "\(some)" : "\(some.dynamicType)"
}

let vehicle = Vehicle.foo()
let tractor = Tractor.foo()

print(typeName(vehicle)) // Vehicle
print(typeName(tractor)) // Tractor

есть еще один способ сделать то, что вы хотите, что включает в себя использование связанного типа Swift. Вот простой пример:

public protocol Creatable {

    associatedtype ObjectType = Self

    static func create() -> ObjectType
}

class MyClass {

    // Your class stuff here
}

extension MyClass: Creatable {

    // Define the protocol function to return class type
    static func create() -> MyClass {

         // Create an instance of your class however you want
        return MyClass()
    }
}

let obj = MyClass.create()

следуя предложению Роба, это можно сделать более общим с соответствующего типа. Я немного изменил пример, чтобы продемонстрировать преимущества этого подхода.

protocol Copyable, NSCopying {
    typealias Prototype
    init(copy: Prototype)
    init(deepCopy: Prototype)
}
class C : Copyable {
    typealias Prototype = C // <-- requires adding this line to classes
    required init(copy: Prototype) {
        // Perform your copying here.
    }
    required init(deepCopy: Prototype) {
        // Perform your deep copying here.
    }
    @objc func copyWithZone(zone: NSZone) -> AnyObject {
        return Prototype(copy: self)
    }
}

у меня была аналогичная проблема, и я придумал что-то, что может быть полезно, поэтому я бы поделился ею для дальнейшего использования, потому что это одно из первых мест, которые я нашел при поиске решения.

как указано выше, проблема заключается в неоднозначности возвращаемого типа для функции copy (). Это можно очень четко проиллюстрировать, разделив функции copy () - > C и copy () - > P:

Итак, предполагая, что вы определяете протокол и класс как следует:

protocol P
{
   func copy() -> P
}

class C:P  
{        
   func doCopy() -> C { return C() }       
   func copy() -> C   { return doCopy() }
   func copy() -> P   { return doCopy() }       
}

это компилирует и дает ожидаемые результаты, когда тип возвращаемого значения является явным. Каждый раз, когда компилятор должен решить, каким должен быть возвращаемый тип (сам по себе), он найдет ситуацию неоднозначной и потерпит неудачу для всех конкретных классов, реализующих протокол P.

например:

var aC:C = C()   // aC is of type C
var aP:P = aC    // aP is of type P (contains an instance of C)

var bC:C         // this to test assignment to a C type variable
var bP:P         //     "       "         "      P     "    "

bC = aC.copy()         // OK copy()->C is used

bP = aC.copy()         // Ambiguous. 
                       // compiler could use either functions
bP = (aC as P).copy()  // but this resolves the ambiguity.

bC = aP.copy()         // Fails, obvious type incompatibility
bP = aP.copy()         // OK copy()->P is used

В заключение, это будет работать в ситуациях, когда вы либо не используете функцию copy() базового класса, либо всегда имеют явный контекст типа.

я обнаружил, что используя то же имя функции, что и конкретный класс, созданный для громоздкого кода везде, поэтому я в конечном итоге использовал другое имя для функции copy() протокола.

конечный результат больше похож:

protocol P
{
   func copyAsP() -> P
}

class C:P  
{
   func copy() -> C 
   { 
      // there usually is a lot more code around here... 
      return C() 
   }
   func copyAsP() -> P { return copy() }       
}

конечно, мой контекст и функции совершенно разные, но в духе вопроса я старался оставаться как можно ближе к приведенному примеру.

просто бросает свою шляпу на ринг здесь. Нам нужен был протокол, который возвращал необязательный тип, к которому применялся протокол. Мы также хотели, чтобы переопределение явно возвращало тип, а не только Self.

трюк заключается в том, что вместо использования "Self" в качестве возвращаемого типа вы вместо этого определяете связанный тип, который вы устанавливаете равным Self, а затем используете этот связанный тип.

вот старый способ, используя себя...

protocol Mappable{
    static func map() -> Self?
}

// Generated from Fix-it
extension SomeSpecificClass : Mappable{
    static func map() -> Self? {
        ...
    }
}

вот новый способ использования связанный тип. Обратите внимание, что возвращаемый тип теперь явный, а не 'Self'.

protocol Mappable{
    associatedtype ExplicitSelf = Self
    static func map() -> ExplicitSelf?
}

// Generated from Fix-it
extension SomeSpecificClass : Mappable{
    static func map() -> SomeSpecificClass? {
        ...
    }
}

добавить к ответам с associatedtype таким образом, я предлагаю переместить создание экземпляра к реализации по умолчанию расширения протокола. Таким образом, соответствующие классы не должны будут реализовывать его, тем самым избавляя нас от дублирования кода:

protocol Initializable {
    init()
}

protocol Creatable: Initializable {
    associatedtype Object: Initializable = Self
    static func newInstance() -> Object
}

extension Creatable {
    static func newInstance() -> Object {
        return Object()
    }
}

class MyClass: Creatable {
    required init() {}
}

class MyOtherClass: Creatable {
    required init() {}
}

// Any class (struct, etc.) conforming to Creatable
// can create new instances without having to implement newInstance() 
let instance1 = MyClass.newInstance()
let instance2 = MyOtherClass.newInstance()