Protocol func returning Self

Question

I have a protocol P that returns a copy of the object:

protocol P {
    func copy() -> Self
}

and a class C that implements P:

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

However, whether I put the return value as Self I get the following error:

Cannot convert return expression of type 'C' to return type 'Self'

I also tried returning C.

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

That resulted in the following error:

Method 'copy()' in non-final class 'C' must return Self to conform to protocol 'P'

Nothing works except for the case where I prefix class C with final ie do:

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

However if I want to subclass C then nothing would work. Is there any way around this?

Riata

What do you mean by "nothing works?" – Anemometry

The compiler complains when putting either C or Self as the return value unless the class is a final class – Riata

OK, I've reproduced the errors, but when asking questions, you need to include the actual error that is returned. Not just "it gives errors" or "it doesn't work." – Anemometry

The compiler is completely correct in its errors here, BTW. I'm just thinking about whether you can get the thing you're trying to do at all. – Anemometry

So there's nothing like instancetype in Objective-C? – Riata

That's not the problem. You can't call [[instancetype alloc] init] either. – Anemometry

But you can call [[[self class] alloc] init]. So I guess the question is that is there a type-safe way to call the current class and call an init method? – Riata

@aeubanks: Yes, you can do self.dynamicType(). The initializer you call must be declared required, because initializers are not always inherited in Swift. – Unbidden

Answer 1

The problem is that you're making a promise that the compiler can't prove you'll keep.

So you created this promise: Calling copy() will return its own type, fully initialized.

But then you implemented copy() this way:

func copy() -> Self {
    return C()
}

Now I'm a subclass that doesn't override copy(). And I return a C, not a fully-initialized Self (which I promised). So that's no good. How about:

func copy() -> Self {
    return Self()
}

Well, that won't compile, but even if it did, it'd be no good. The subclass may have no trivial constructor, so D() might not even be legal. (Though see below.)

OK, well how about:

func copy() -> C {
    return C()
}

Yes, but that doesn't return Self. It returns C. You're still not keeping your promise.

"But ObjC can do it!" Well, sort of. Mostly because it doesn't care if you keep your promise the way Swift does. If you fail to implement copyWithZone: in the subclass, you may fail to fully initialize your object. The compiler won't even warn you that you've done that.

"But most everything in ObjC can be translated to Swift, and ObjC has NSCopying." Yes it does, and here's how it's defined:

func copy() -> AnyObject!

So you can do the same (there's no reason for the ! here):

protocol Copyable {
  func copy() -> AnyObject
}

That says "I'm not promising anything about what you get back." You could also say:

protocol Copyable {
  func copy() -> Copyable
}

That's a promise you can make.

But we can think about C++ for a little while and remember that there's a promise we can make. We can promise that we and all our subclasses will implement specific kinds of initializers, and Swift will enforce that (and so can prove we're telling the truth):

protocol Copyable {
  init(copy: Self)
}

class C : Copyable {
  required init(copy: C) {
    // Perform your copying here.
  }
}

And that is how you should perform copies.

We can take this one step further, but it uses dynamicType, and I haven't tested it extensively to make sure that is always what we want, but it should be correct:

protocol Copyable {
  func copy() -> Self
  init(copy: Self)
}

class C : Copyable {
  func copy() -> Self {
    return self.dynamicType(copy: self)
  }

  required init(copy: C) {
    // Perform your copying here.
  }
}

Here we promise that there is an initializer that performs copies for us, and then we can at runtime determine which one to call, giving us the method syntax you were looking for.

Anemometry

Hmm, they must have changed this. I could have swore that func copy() -> C worked in previous betas, and it was consistent because protocol conformance was not inherited. (Now it seems protocol conformance is inherited, and func copy() -> C does not work.) – Unbidden

The last pure-Swift solution does not work with subclasses as they are required to implement init(copy: C) instead init(copy: Self) :( – Satori

The last solution guarantees the return value to be Self but the initializer then all have to accept a variable statically typed to C which is to say, it's not much improvement to just returning AnyObject in the first place. – Cryoscopy

I'd say it's still a big improvement over AnyObject, but it is true that it means that you have to be able to copy your superclasses (so there have to be default values for your subclass properties, or you have to use fatalError() or the like, which is ugly). The problem does go away if you get rid of the Copyable protocol. It all behaves as expected as long as you just implement init(copy:) without promising to so (but it also won't force you to implement init(copy:) at each layer. See https://mcmap.net/q/225943/-getting-clone-of-superclass and also devforums.apple.com/message/1086442 – Anemometry

In swift 2.0 you'd have to call init explicitly: self.dynamicType.init( ... ) – Abdomen

@RobNapier Thanks for the great answer but I don't understand the beginning yet. You say 'And I return a C, not a fully-initialized Self (which I promised)' but I thought a Self within the class C is the same as writing C, isn't it? So a C should be a Self in that context respectively, no? Doesn't seem so but I don't really understand why. – Sinaloa

@Dschee inside of C, Self could be C or a subclass of C. Those are different types. – Anemometry

FWIW for an enum it works. I wonder why: protocol Selfer { func back() -> Self } enum Letter: Selfer { case a case b func back() -> Letter { return Letter.a } } print(Letter.a.back()) // b – Chorion

Answer 2

With Swift 2, we can use protocol extensions for this.

protocol Copyable {
    init(copy:Self)
}

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

Bunche

This is a great answer and that type of approach was discussed extensively on WWDC 2015. – Polymorphonuclear

This should be the accepted answer. It can be simplified with return Self(copy: self) (in Swift 2.2 at least). – Rubbico

Answer 3

There is another way to do what you want that involves taking advantage of Swift's associated type. Here's a simple example:

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

Fearnought

Fascinating. I wonder if that relates to https://mcmap.net/q/225944/-returning-the-subclass-in-a-uiviewcontroller-static/294884 – Oldtimer

This one does what I'm interested in. Thanks! – Steffin

Answer 4

Actually, there is a trick that allows to easily return Self when required by a protocol (gist):

/// 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

Leslie

Wow. compiles. That's tricksy, because the compiler won't let you just return Vehicle() as! Self – Eastbound

that is mindboggling. Wow. Is what I'm asking here actually a variation on this?? https://mcmap.net/q/225944/-returning-the-subclass-in-a-uiviewcontroller-static/294884 – Oldtimer

@JoeBlow I'm afraid it isn't. I'd say that to keep our minds safe we should know the return type exactly (i.e. not "A or B", but just "A"; otherwise we must think about polymorphism + inheritance + function overloading (at least). – Leslie

that's compiler tricking. Since overriding of foo() is not enforced, every Vehicle descendant without foo() custom implementation will produce obvious crash in autocast(). For example: class SuperCar: Vehicle { } let superCar = SuperCar.foo() . Instance of Vehicle can't be downcasted to SuperCar - so force unwrapping of nil in 'autocast()' leads to crash. – Acaricide

@Acaricide Changing the code to the following does not crash when a subclass does not override foo(). The only requirement is that class Foo must have a required initializer for this to work as shown below. class Vehicle: Foo { public required init() { // Some init code here } class func foo() -> Self { return autocast(self.init())! // return autocast(Vehicle())! } } class Tractor: Vehicle { //Override is not necessary /*override class func foo() -> Self { return autocast(Tractor())! }*/ } – Calculator

Answer 5

Swift 5.1 now allow a forced cast to Self, as! Self

Given

protocol P { 
     func id() -> Self 
 } 

This works:

 class D : P { 
     func id() -> Self { 
         return D() as! Self
     } 
 }

Without the as! Self, you get an error:

error: repl.swift:11:16: error: cannot convert return expression of type 'D' to return type 'Self'
        return D()
               ^~~
                   as! Self

Archiepiscopal

Answer 6

Following on Rob's suggestion, this could be made more generic with associated types. I've changed the example a bit to demonstrate the benefits of the approach.

protocol Copyable: NSCopying {
    associatedtype 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)
    }
}

Implore

Answer 7

I had a similar problem and came up with something that may be useful so I though i'd share it for future reference because this is one of the first places I found when searching for a solution.

As stated above, the problem is the ambiguity of the return type for the copy() function. This can be illustrated very clearly by separating the copy() -> C and copy() -> P functions:

So, assuming you define the protocol and class as follows:

protocol P
{
   func copy() -> P
}

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

This compiles and produces the expected results when the type of the return value is explicit. Any time the compiler has to decide what the return type should be (on its own), it will find the situation ambiguous and fail for all concrete classes that implement the P protocol.

For example:

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

In conclusion, this would work in situations where you're either, not using the base class's copy() function or you always have explicit type context.

I found that using the same function name as the concrete class made for unwieldy code everywhere, so I ended up using a different name for the protocol's copy() function.

The end result is more like:

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

Of course my context and functions are completely different but in spirit of the question, I tried to stay as close to the example given as possible.

Fourteen

Answer 8

Just throwing my hat into the ring here. We needed a protocol that returned an optional of the type the protocol was applied on. We also wanted the override to explicitly return the type, not just Self.

The trick is rather than using 'Self' as the return type, you instead define an associated type which you set equal to Self, then use that associated type.

Here's the old way, using Self...

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

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

Here's the new way using the associated type. Note the return type is explicit now, not 'Self'.

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

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

Anthropomorphize

Update: I think Swift properly lets you use Self as the return type now. There was a change in the compiler. I haven't had to use such a workaround in a while. – Anthropomorphize

Answer 9

To add to the answers with the associatedtype way, I suggest to move the creating of the instance to a default implementation of the protocol extension. In that way the conforming classes won't have to implement it, thus sparing us from code duplication:

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

Weakly