[swift-evolution] [RFC] #Self

[Vladimir.S]

On 11.05.2016 16:42, Matthew Johnson wrote:
> With #Self (or Type as we're now calling it) they would not need to
> override those requirements because the ancestor that initially declared
> conformance provides an inherited implementation that remains valid for
> all of its descendants.

OK.. I see your point, thank you. But probably we thinks differently about 
the #Self 'behavior' and how it should be treated in case of protocol 
conformance.

First of all, the initial proposal (which I base all my understanding on):
On 10.05.2016 16:15, Erica Sadun via swift-evolution wrote:
 >----------------------------------<
To focus SE-0068 and narrow its scope, I removed the `#Self` part of the 
proposal. This offered compile-time substitution of the defining type for a 
related #Self literal:

     A further static identifier, #Self expands to static type of the code 
it appears within, completing the ways code may want to refer to the type 
it is declared in.

         #Self expands to the static type of the code it is declared 
within. In value types, this is always the same as Self. In reference 
types, it refers to the declaring type. #Self will offer a literal textual 
replacement just like #file, etc.
 >----------------------------------<

So, again, we have protocol

protocol A {
   func f()->#Self
}

What does it mean for me? : Each class C, conformed to protocol A, should 
have func f() that returns exactly this class.

so, let's have

class B: A {
   func f()->B {} // conforms to protocol
// or could be written as(the same):
//func f()->#Self {} // conforms to protocol
}

class C: A {
   func f()->C {} // conforms to protocol
}

class D: A {
   func f()->D {} // conforms to protocol
}

and now, you want to conform some existed non-final class to A protocol:

class E {
   func f()->E {} // just has such method
}

extension E: A {} // seems like OK at this step

after this, what's the state of some existed derived from E classes ?

class F: E {}
class G: F {}

You conformed the base class E to A protocol. This automatically *reuqire* 
that F & G also conforms to A protocol. They *must* be `is A`.
But I insist, they does not conform to A protocol as I understand the #Self 
proposal.

F().f() *must*(because of protocol A) return instance of F, but F only has 
f()->C from base class

G().f() *must*(because of protocol A) return instance of G, but G only has 
f()->C from base class

This is why I don't understand how #Self could help to achieve the target 
with NSURL conformance.
These are my points. Please point if I'm wrong somewhere.