1. 泛型函数

func swapTwoValues(_ a: inout T, _ b: inout T) {
    let t = a
    a = b
    b = t
}

var someInt = 3
var anotherInt = 7
swapTwoValues(&someInt, &anotherInt)
print("\(someInt), \(anotherInt)")
// print "7, 3"

var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)

T 是占位类型名，用来代替实际类型名。

2. 泛型类型

下面的例子定义了一个泛型的栈（stack）结构体，从而能够处理任意类型的值。

struct Stack {
    var items = [Element]()
    mutating func push(item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
}

var stackOfStrings = Stack()
stackOfStrings.push(item: "A")
stackOfStrings.push(item: "B")
stackOfStrings.push(item: "C")

let fromTheTop = stackOfStrings.pop()

3. 扩展一个泛型类型

extension Stack {
    var topItem: Element? {
        return items.isEmpty ? nil : items[items.count - 1]
    }
}

stackOfStrings.topItem // "B"

4. 类型约束

func findIndex(ofString valueToFind: String, in array: [String]) -> Int? {
    for(index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}
let strings = ["A", "B", "C"]
if let foundIndex = findIndex(ofString: "B", in: strings) {
    print("\(foundIndex)")
}
// print "1"

上面的例子展示了在一个字符串数组中找到对应字符串的索引，但是并不适用于包含其他类型的元素的数组。

func findIdex(array: [T], _ valueToFind: T) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

Equatable 给占位类型 T 添加了类型约束，意味着上面的函数只能包含 Equatable 类型的元素。不是所有的 Swift 类型都可以用 == 进行比较，除非该类型遵循了 Equatable 协议。

5. 关联类型

关联类型为协议中的某个类型提供了一个占位名，其代表的实际类型在协议被采纳时才会被指定，用关键字 associatedtype 关键字来指定关联类型。

protocol Container {
    associatedtype ItemType
    mutating func append(item: ItemType)
    var count: Int { get }
    subscript(i: Int) -> ItemType  { get }
}

我们还可以通过扩展一个存在的类型来指定关联类型，比如：

extension Array: Container {}

6. 泛型Where语句

where 字据可以给一个关联类型添加类型约束，语法如下：

func genericFunc(p: S) -> returnType where #判断语句# {
}

Swift中的泛型