> As I understand it, the proposal is that `Self` can be used as an alias to
> `self.dynamicType`, which is an object in the sense of entity in Swift but
> not an instance of a class or struct.
You don't understand it correctly.
Currently, `Self` in a class definition means "whatever subclass this object
happens to be". So if you say this:
class Parent {
func foo() -> Self
}
class Child: Parent {}
Then on `Child`, the `foo()` function returns `Self`.
`Self` isn't supported in value types because, since you can't subclass value
types, it always means exactly the same thing as writing the type's name.
`Self` also isn't supported in the bodies of class members because, when you
call members on it, it's equivalent to `self.dynamicType`. This is actually
really strange, though, because it means that you can't actually write certain
types explicitly. For instance:
class Foo {
func foo() -> Self {
let new = self.dynamicType.init()
// `new` is of type Self, but you can't actually write `let
new: Self`
return new
}
required init() {}
}
What this proposal is saying is:
* `Self` will be allowed in value types. It will always mean the same thing as
writing the type's name explicitly, but that's okay; it's more readable.
* `Self` will be allowed in member bodies. This will allow you to write that
`new` line as:
let new: Self = Self()
Oh, and `#Self` will also be permitted, which is always literally just a
shorthand for whatever type you happen to be in right now.
> My point, though is not the exact semantics of what you call the thing that
> `Self` is but that having it and `self` in the same code will lead to
> readability issues because you can have `self` and `Self` in the same code
> referring to completely different things and they only differ in the case of
> the first letter.
People seem to be okay with things like `var string: String`; having `self` be
of type `Self` is no different.
* * *
Having said all this, now that we have `#Self`, I'm wondering if we still want
`Self` in value types. The two are *exactly* equivalent in value types as far
as I can tell, and `Self` in classes implies dynamic behavior which is not
supported by value types. The use of `Self` in class member bodies is a clean
win, the existence of `#Self` is a clean win, but I'm not sure we need the
value type thing too.
--
Brent Royal-Gordon
Architechies
_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
