2019 update: in version 5.1 it will be possible to use Self in concrete context, and not just in protocols and protocols extensions. I will properly update this post once 5.1 is released. The rest of this post describes pre-5.1 behaviour.
Anyone who study Swift programming language surely knows what keyword
self means — it is reference to current object inside class instance context. Completely normal stuff in almost any objective language. The tricky part begins when one deals with static methods and properties as well as with the famous Swift's protocol-oriented paradigm. We won't emphasize attention on protocol philosophy, instead let's proceed to the most interesting part, and I'm quite sure anyone had business with it.
I'm talking about calling static method from protocol extension or defining a protocol method which must return eventual type. All of that is a particular case of late static binding, and everybody may google it anytime.
It's quite straight and simple in case of commonplace static method inside class or structure — method is easily called with type name, or you just call
type(of: self) which returns current type and from that you may call static methods. However when there is no concrete type yet, but only protocol and/or its extensions (i.e. metatype), language simply won't let us do it because protocol cannot contain implementation and protocol extension is not considered as concrete code, hence we get compiler error
Static member 'staticMethodName' cannot be used on protocol metatype 'ProtocolName.Protocol'.
The solution is using keyword
Self (exactly that, capitalized) which is a reference to eventual type conforming to protocol. Official documentation has only one mentioning of this keyword:
In that [protocol] context, Self refers to the eventual type that conforms to the protocol.
Respectively, this keyword works only in metatype context (protocols and protocol extensions), in concrete classes or structures you get error
Use of unresolved identifier 'Self'.