类型

typealias PQ = P & Q
typealias PQR = PQ & Q & R

协议合成类型语法

protocol-composition-type

协议合成类型 → 协议标识符 & 协议合成延续

protocol-composition-continuation

协议合成延续 → 协议标识符 | 协议合成类型

不透明类型

不透明类型 定义了一个遵循某个协议或者合成协议的类型，但不需要指明底层的具体类型。

不透明类型可以作为函数或下标的返回值类型，亦或是属性的类型使用。

不透明类型不能作为元组类型的一部分或范型类型使用，比如数组元素类型或者可选值的包装类型。

不透明类型的形式如下：

some constraint

constraint 可以是类类型，协议类型，协议组合类型或者 Any 。只有当一个值的类型遵循该协议或者组合协议，或者从该类继承的时候，这个值才能作为这个不透明类型的实例使用。和不透明值交互的代码只能使用该值定义在 constraint 上的接口。

协议声明里不能包括不透明类型。类不能使用不透明类型作为非 final 方法的返回值类型。

使用不透明类型作为返回值类型的函数必须返回单一公用底层类型。返回值的类型可以包含函数范型类型形参的一部分。例如，函数 someFunction<T>() 可以返回类型为 T 或者 Dictionary<String,T> 的值。

不透明类型语法

opaque-type

不透明类型 → some type

元类型

元类型 是指任意类型的类型，包括类类型、结构体类型、枚举类型和协议类型。

类、结构体或枚举类型的元类型是相应的类型名紧跟 .Type 。协议类型的元类型——并不是运行时遵循该协议的具体类型——是该协议名字紧跟 .Protocol 。比如，类 SomeClass 的元类型就是 SomeClass.Type ，协议 SomeProtocol 的元类型就是 SomeProtocal.Protocol 。

你可以使用后缀 self 表达式来获取类型。比如， SomeClass.self 返回 SomeClass 本身，而不是 SomeClass 的一个实例。同样， SomeProtocol.self 返回 SomeProtocol 本身，而不是运行时遵循 SomeProtocol 的某个类型的实例。还可以对类型的实例使用 type(of:) 表达式来获取该实例动态的、在运行阶段的类型，如下所示：

class SomeBaseClass {
    class func printClassName() {
        println("SomeBaseClass")
class SomeSubClass: SomeBaseClass {
    override class func printClassName() {
        println("SomeSubClass")
let someInstance: SomeBaseClass = SomeSubClass()
// someInstance 在编译期是 SomeBaseClass 类型，
// 但是在运行期则是 SomeSubClass 类型
type(of: someInstance




    
).printClassName()
// 打印“SomeSubClass”

class AnotherSubClass: SomeBaseClass {
    let string: String
    required init(string: String) {
        self.string = string
    override class func printClassName() {
        print("AnotherSubClass")
let metatype: AnotherSubClass.Type = AnotherSubClass.self
let anotherInstance = metatype.init(string: "some string")

let mixed: [Any] = ["one", 2, true, (4, 5.3), { () -> Int in return 6 }]

if let first = mixed.first as? String {
    print("The first item, '\(first)', is a string.")
// 打印 "The first item, 'one', is a string."

class Superclass {
    func f() -> Self { return self }
let x = Superclass()
print(type(of: x.f()))
// 打印 "Superclass"
class Subclass: Superclass { }
let y = Subclass()
print(type(of: y.f()))