Question about using Self keyword and opaque return type Some in protocol extensions

I am beginning to learn some Swift at the moment and I have been following the 100 Days of Swift on Hacking with Swift (Day 13). I have a question about using the Self keyword.

extension Numeric {
    func squared() -> Self {
        self * self
    }
}

In the above section of code, the author notes that to add the protocol extension to have squared functionality we can use the Self keyword so that the specific type (i.e. int, double) of the calling Numeric type is referenced. However, I was wondering could we just replace Self with some Numeric instead? Would that also accomplish the same task because the compiler could figure out what exact type was being referenced in this instance when squared() is called? What is the difference between these calls?

> However, I was wondering could we just replace Self with some Numeric instead?

Yes, but only in the sense that the extension itself will still compile. The compiler can indeed see that self * self is an expression of type Self, and Self trivially conforms to Numeric, and so can be returned in a method returning some Numeric.

However, callers of squared will probably break, and that is where the difference is.

The idea of some is that callers don't know what the actual type returned is. If you were returning Self, the caller has the guarantee that x.squared() is the same type as x. But with some Numeric, the caller only knows that squared returns a type conforming to Numeric, but doesn't know which specific type it is.

This means that it is possible to implement squared like this (not that this makes any sense):

extension Numeric { 
    func squared() -> some Numeric { 
        Date().timeIntervalSince1970
    } 
}

After all, timeIntervalSince1970 returns TimeInterval. which is also Numeric.

Example:

func doSomethingWithInts(_ x: Int) { ... }

let x = 2
let y = x.squared() // if squared returns "some Numeric"...
print(y.bitWidth) // this is not allowed
doSomethingWithInts(y) // nor is this

After all. squared could be implemented to return any specific Numeric-conforming type, not necessarily the same type as x. What if it returned TimeInterval? There is no bitWidth there.

If squared returned Self on the other hand, then the caller knows that y is Int, for the reason that x is Int, and you can do all those things shown above that you were not allowed to do.

Note that although the caller doesn't know what specific type some Numeric is, it does know that it is the same type every time. For example, this works:

let a = 2
let b = 3
var x = a.squared() // calling squared on Int returns "some Numeric"
// the Numeric type returned by the call below is the same type as a.squared()
// because b is also Int, so the assignment is allowed
x = b.squared() 
print(x)

This is a bit off-topic, but the above is what differentiates some Numeric and any Numeric.

Read more about some in this post.

You could use some Numeric, but it's a weaker guarentee:

extension Numeric {
    func squared() -> some Numeric {
      // Just a dummy implementation, ignore the details
      // The opaque return type is always an `Int`, regardless of `Self`.
      123
    }
}

let iThoughtThisWouldBeADouble = 2.0.squared()

print(type(of: iThoughtThisWouldBeADouble)) // Surprise, it's an Int.

In this example, squared() can return the same type as self, but it's not obligated to, as shown. Self (Double in this example) is just one example that satisfies some Numeric, but any other Numeric-conforming type (like Int) can also fit.