//泛型
//泛型代码可以让你写出根据自我需求定义、适用于任何类型的 灵活且可重用的函数和类型
//可以避免重复的代码 用一种清晰和抽象的方式来表达代码的意图

func swapTwoValues<T>(inout a:T, inout _ b:T){
let temp = a
a = b
b = temp
}

var someInt = 3
var anotherInt = 107
print("someInt:(someInt) anotherInt:(anotherInt)")
swapTwoValues(&someInt, &anotherInt)
print("someInt:(someInt) anotherInt:(anotherInt)")

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

//泛型扩展
extension Stack {
var topItem: T?{
return items.isEmpty ?nil :items[items.count - 1]
}
}

var stackOfStrings = Stack<String>()
stackOfStrings.push("a")
stackOfStrings.push("b")
stackOfStrings.push("c")
stackOfStrings.push("d")

stackOfStrings.pop()

if let topItem = stackOfStrings.topItem{
print("The top item on the stack is (topItem)")
}

print(stackOfStrings)

//类型约束语法
// func someFunction<T: someClass, U: someProtocol>(someT: T, someU: U){}

//类型约束实例
//T: Equatable 表明T这个类型都遵守Equatable协议
func findIndex<T: Equatable>(array:[T], _ valueToFind: T) -> Int?{
for (index, value) in array.enumerate(){
if value == valueToFind{
return index
}
}
return nil
}

let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
let stringIndex = findIndex(["Mike", "Malo", "Andrea"], "Andrea")

print("doubleIndex:(doubleIndex) stringIndex:(stringIndex)")

//关联类型
//mutating表示可以在方法內修改实例变量的值
// protocol Container {
// typealias ItemType
// mutating func append(item: ItemType)
// var count: Int {get}
// subscript(i: Int) -> ItemType { get }
// }

// struct InStack: Container {
// var items = Int
// mutating func push(item: Int){
// items.append(item)
// }
// mutating func pop() -> Int{
// return items.removeLast()
// }
// typealias ItemType = Int
// mutating func append(item: Int){
// self.push(item)
// }
// var count: Int{
// return items.count
// }
// subscript(i: Int) -> Int {
// return items[i]
// }
// }