Swift---泛型(Generics)

//Int类型交换
func swapTwoInts(inout a: Int, inout b: Int){
  let temp = a
  a = b
  b = temp
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

// prints "someInt is now 107, and anotherInt is now 3"

//String类型交换
func swapTwoStrings(inout a: String, inout b: String){
  let temp = a
  a = b
  b = temp
}

//Double类型交换
func swapTwoDoubles(inout a: Double, inout b: Double){
  let temp = a
  a = b
  b = temp
}

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

var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt)
// someInt is now 107, and anotherInt is now 3

var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)
// someString is now "world", and anotherString is now "hello"

struct IntStack{
  var items = Int[]()
  mutating func push(item: Int){
    item.append(item)
  }

  mutating func pop() -> Int {
    return items.removeLast()
  }
}

struct Stack<T>{
  var items = T[]()
  mutating func push(item: T){
    items.append(item)
  }

  mutating func pop() -> T {
    return items.removeLast()
  }
}

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
// the stack now contains 4 strings

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

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

func findStringIndex(array: String[], valueToFind: String) -> Int? {
  for(index, value) in enumerate(array) {
    if value == valueToFind {
      return index
    }
  }
  return nil
}

let strings = ["cat", "dog", "llama", "parakeet", "terrapin"]
if let foundIndex = findStringIndex(strings, "llama") {
  println("The index of llama is \(foundIndex)")
}

// prints "The index of llama is 2"

func findIndex<T>(array: T[], valueToFind: T) -> Int? {
  for(index, value) in enumerate(array) {
    if value == valueToFind {
      return index
    }
  }
  return nil
}

func findIndex<T: Equatable>(array: T[], valueToFind: T) -> Int? {
  for(index, value) in enumerate(array) {
    if value == valueToFind {
      return index
    }
  }
  return nil
}

let doubleIndex = findIndex([3.14159, 0.1, 0.25], 9.3)
// doubleIndex is an optional Int with no value,
// because 9.3 is not in the array

let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], "Andrea")
// stringIndex is an optional Int containing a value of 2