在尖括号里写一个名字来创建一个泛型函数或者类型 例如<T>、<Type>

可以创建泛型类、枚举和结构体

在类型后使用where来指定一个需求列表。例如，要限定实现一个协议的类型，需要限定两个类型要相同，或者限定一个类必须有一个特定的父类

先给一个具体举例如下：

//泛型函数

func repeat<ItemType>(item:ItemType,times:Int)->[ItemType]{

    var results:[ItemType] = [ItemType]()

    for i in ..<times{

        results.append(item)

    }

    return results

}

//第一个参数可以接收任意类型的数据

repeat("Tom", )       //字符串

repeat(, )          //整数

repeat((,,,), )   //元组

显示结果：

1. func swapTwoInts(inout a: Int, inout b: Int)
2. let temporaryA = a
3. a = b
4. b = temporaryA
5. }

1. var someInt = 3
2. var anotherInt = 107
3. swapTwoInts(&someInt, &anotherInt)
4. println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
5. // 输出 "someInt is now 107, and anotherInt is now 3"

1. func swapTwoStrings(inout a: String, inout b: String) {
2. let temporaryA = a
3. a = b
4. b = temporaryA
5. }
6. func swapTwoDoubles(inout a: Double, inout b: Double) {
7. let temporaryA = a
8. a = b
9. b = temporaryA
10. }

1. func swapTwoValues<T>(inout a: T, inout b: T) {
2. let temporaryA = a
3. a = b
4. b = temporaryA
5. }

1. func swapTwoInts(inout a: Int, inout b: Int)
2. func swapTwoValues<T>(inout a: T, inout b: T)

1. var someInt = 3
2. var anotherInt = 107
3. swapTwoValues(&someInt, &anotherInt)
4. // someInt is now 107, and anotherInt is now 3
5. var someString = "hello"
6. var anotherString = "world"
7. swapTwoValues(&someString, &anotherString)
8. // someString is now "world", and anotherString is now "hello"

1. struct IntStack {
2. var items = [Int]()
3. mutating func push(item: Int) {
4. items.append(item)
5. }
6. mutating func pop() -> Int {
7. return items.removeLast()
8. }
9. }

1. struct Stack<T> {
2. var items = [T]()
3. mutating func push(item: T) {
4. items.append(item)
5. }
6. mutating func pop() -> T {
7. return items.removeLast()
8. }
9. }

1. var stackOfStrings = Stack<String>()
2. stackOfStrings.push("uno")
3. stackOfStrings.push("dos")
4. stackOfStrings.push("tres")
5. stackOfStrings.push("cuatro")
6. // 现在栈已经有4个string了

1. let fromTheTop = stackOfStrings.pop()
2. // fromTheTop is equal to "cuatro", and the stack now contains 3 strings

 

1. func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
2. // function body goes here
3. }

1. func findStringIndex(array: [String], valueToFind: String) -> Int? {
2. for (index, value) in enumerate(array) {
3. if value == valueToFind {
4. return index
5. }
6. }
7. return nil
8. }

1. let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
2. if let foundIndex = findStringIndex(strings, "llama") {
3. println("The index of llama is \(foundIndex)")
4. }
5. // 输出 "The index of llama is 2"

1. func findIndex<T>(array: [T], valueToFind: T) -> Int? {
2. for (index, value) in enumerate(array) {
3. if value == valueToFind {
4. return index
5. }
6. }
7. return nil
8. }

1. func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
2. for (index, value) in enumerate(array) {
3. if value == valueToFind {
4. return index
5. }
6. }
7. return nil
8. }

1. let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
2. // doubleIndex is an optional Int with no value, because 9.3 is not in the array
3. let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
4. // stringIndex is an optional Int containing a value of 2

1. protocol Container {
2. typealias ItemType
3. mutating func append(item: ItemType)
4. var count: Int { get }
5. subscript(i: Int) -> ItemType { get }
6. }

1. struct IntStack: Container {
2. // original IntStack implementation
3. var items = [Int]()
4. mutating func push(item: Int) {
5. items.append(item)
6. }
7. mutating func pop() -> Int {
8. return items.removeLast()
9. }
10. // conformance to the Container protocol
11. typealias ItemType = Int
12. mutating func append(item: Int) {
13. self.push(item)
14. }
15. var count: Int {
16. return items.count
17. }
18. subscript(i: Int) -> Int {
19. return items[i]
20. }
21. }

1. struct Stack<T>: Container {
2. // original Stack<T> implementation
3. var items = [T]()
4. mutating func push(item: T) {
5. items.append(item)
6. }
7. mutating func pop() -> T {
8. return items.removeLast()
9. }
10. // conformance to the Container protocol
11. mutating func append(item: T) {
12. self.push(item)
13. }
14. var count: Int {
15. return items.count
16. }
17. subscript(i: Int) -> T {
18. return items[i]
19. }
20. }

1. extension Array: Container {}

1. func allItemsMatch<
2. C1: Container, C2: Container
3. where C1.ItemType == C2.ItemType, C1.ItemType: Equatable>
4. (someContainer: C1, anotherContainer: C2) -> Bool {
5. // check that both containers contain the same number of items
6. if someContainer.count != anotherContainer.count {
7. return false
8. }
9. // check each pair of items to see if they are equivalent
10. for i in 0..someContainer.count {
11. if someContainer[i] != anotherContainer[i] {
12. return false
13. }
14. }
15. // all items match, so return true
16. return true
17. }

1. var stackOfStrings = Stack<String>()
2. stackOfStrings.push("uno")
3. stackOfStrings.push("dos")
4. stackOfStrings.push("tres")
5. var arrayOfStrings = ["uno", "dos", "tres"]
6. if allItemsMatch(stackOfStrings, arrayOfStrings) {
7. println("All items match.")
8. } else {
9. println("Not all items match.")
10. }
11. // 输出 "All items match."