泛型能让我们使用的类型和函数使用未知的类型，许多内置类型，例如可空类型，数组和字典都是用泛型实现的。
泛型类型
下面的结构体实现了一个简单的栈，可以对Int类型执行push和pop操作。
struct Stack{
var items = [Int]()
mutating func push(newitem:Int){
items.append(newitem)
}
mutating func pop() ->Int?{
guard !items.isEmpty else{
return nil
}
return items.removeLast()
}
}
var stack=Stack()
stack.push(newitem:1)
stack.push(newitem:2)
print(stack.pop())
print(stack.pop())
但是如果我们需要对其他类型进行入栈和出栈操作，那就得再编写一个栈类型，使用泛型可以让这个栈支持任意类型。改写后的代码如下，Swift的泛型语法和Java差不多。
struct Stack<T>{
var items = [T]()
mutating func push(newitem:T){
items.append(newitem)
}
mutating func pop() ->T?{
guard !items.isEmpty else{
return nil
}
return items.removeLast()
}
}
var stack=Stack<Int>()
stack.push(newitem:1)
stack.push(newitem:2)
print(stack.pop())
print(stack.pop())
多个占位类型
泛型可支持多个占位类型，代码如下。
struct Stack<T,U,X>{
var items = [T]()
var items1 = [U]()
var items2 = [X]()
...
}
var stack=Stack<Int,String,Double>()
泛型函数和方法
泛型函数需要在函数参数列表前声明占位类型，然后可以在参数和返回值中使用这些占位类型。
func getSelf<T>(arg:T)->T{
return arg
}
print(getSelf(arg: "hello world!"))
类型约束
有时候我们需要对传入的类型做一些限制，可以通过类型约束实现，有两种约束：一种是类型必须是给定类的子类，还有一种是类型必须符合一个协议。
func checkEqual<T:Equatable>(first:T,second:T)->Bool{
return first==second
}
print(checkEqual(first: 1, second: 1))
print(checkEqual(first: "123", second: "456"))
当占位类型比较复杂时，我们还可以使用where语句进一步约束占位类型，如下代码要求newitems的元素必须是T类型。
struct Stack<T>{
var items = [T]()
mutating func push(newitem:T){
items.append(newitem)
}
mutating func pushAll<S:Sequence>(newitems:S)
where S.Iterator.Element==T {
for item in newitems {
self.push(newitem: item)
print("push \(item)")
}
}
mutating func pop() ->T?{
guard !items.isEmpty else{
return nil
}
return items.removeLast()
}
}
var stack=Stack<Int>()
stack.pushAll(newitems:[1,2,3,4,5,6])
关联类型协议
协议不支持泛型，但是支持另外一种特性:关联类型，在协议内部可以使用associatedtype关键字声明一个占位类型，符合这个协议的类型应该在其内部为占位类型提供typealias定义。
protocol InteratorProtocol {
associatedtype Element
mutating func next() -> Element?
}
struct Stack<T>:InteratorProtocol {
typealias Element = Int
mutating func next() -> Element? {
return 0
}
}
