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

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

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

 

先给一个具体举例如下：

显示结果：

 

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.  
7. func swapTwoDoubles(inout a: Double, inout b: Double) { 
8.     let temporaryA = a 
9.     a = b 
10.     b = temporaryA 
11. } 

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.  
6. var someString = "hello" 
7. var anotherString = "world" 
8. swapTwoValues(&someString, &anotherString) 
9. // 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.  
6.         // check that both containers contain the same number of items 
7.         if someContainer.count != anotherContainer.count { 
8.             return false 
9.         } 
10.  
11.         // check each pair of items to see if they are equivalent 
12.         for i in 0..someContainer.count { 
13.             if someContainer[i] != anotherContainer[i] { 
14.                 return false 
15.             } 
16.         } 
17.  
18.         // all items match, so return true 
19.         return true 
20. } 

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