Generics

作者: 夜雨聲煩_ | 来源:发表于2018-01-08 18:57 被阅读0次

【The Java™ Tutorials】【Generics】1
Effective Java 3rd-----Chapter 5
Generics
Generics
Objective-C 的轻量泛型
[swift 进阶]读书笔记-第九章：泛型 C9P3 使用泛型
泛型
swift入门22 范型
Item 33: Consider typesafe heter
Concerning Priority Queue(With G

泛型。参数类型不同功能相同的函数有时需定义多个，造成重复，泛型用于解决这种情况。Dictionary和Array是最基本的两个。例如下面一个可以同时交换Int类型、string类型等多个类型的泛型函数
```
//Generaic Functions
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
  let temporatyA = a
  a = b
  b = temporatyA
} 
```
<>内定义占位类型T，并声明传入类型是T类型，T类型的具体类型在调用该函数时由传参推断
系统中使用了一些默认的类型名，例如字典中的Key、Value，数组中的Element，而我们定义的时候通常用T、U、V

泛型类型实例

struct Stack<Element> {
  var items = [Element]()
  mutating func push(_ item: Element) {
      items.append(item)
  }
  mutating func pop() -> Int{
      return items.removeLast()
  }
}
var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
let fromTheTop = stackOfStrings.pop()

使用extension对泛型类型进行扩展，使用类型参数不用重新定义可以直接使用原参数类型
```
extension Stack {
  var topItem: Element? {
      return items.isEmpty ? nil : items[items.count - 1]
  }
}
```
类型约束。有时对于泛型函数和泛型类的使用范围有约束，我们可以指定某些类的子类或者遵循某些协议方可适用。例如字典中key被约束为只有遵循hashable才可以，(such as String, Int, Double, and Bool)

语法

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

实例

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

只有遵循Equatable协议的类才可以使用==符号，如果不声明T为Equatable类型，则可能存在不能使用==符号比较的类，会报错

使用associatedtype在协议中定义关联类型，使用typealias在遵循协议的实现中指定关联类型的具体类型，同时在associatedtype后可以使用冒号进行关联类型限制，如下
```
protocol Container {
  associatedtype Item: Equatable
  mutating func append(_ item: Item)
  var count: Int { get }
  subscript(i: Int) -> Item { get }
}
```

使用

struct IntStack: Container {
    // original IntStack implementation
    var items = [Int]()
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }
    // conformance to the Container protocol
    typealias Item = Int
    mutating func append(_ item: Int) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Int {
        return items[i]
    }
}

对于已经实现某协议的类可以使用extension加空实现体来进行声明
```
extension Array: Container {}
```
使用where在函数声明中增加限制，如果不满足则函数不会被调用且会报错
该函数实现了对不同类型（array和stack），但其中item相同的类型进行比较
```
func allItemsMatch<C1: Container, C2: Container>(_ someContainer: C1, _ anotherContainer: C2) -> Bool where C1.Item == C2.Item, C1.Item: Equatable{
  if someContainer.count != anotherContainer.count {
      return false
  }
  for i in 0..<someContainer.count {
      if someContainer[i] != anotherContainer[i] {
          return false
      }
  }
  return true
}
```
上述代码中包括四个限制
1.C1遵循Container协议（C1: Container）
2.C2遵循Container协议（C2: Container）
3.C1、C2的Item类型一致（C1.Item == C2.Item）
4.C1、C2的Item遵循Equatable协议，即可用==比较（C1.Item: Equatable）

使用where语句在扩展的时候增加限制。如果不增加Equatable的限制会报错：Element不一定能使用==进行判断

//Extension with a Generic Where Clause
extension Stack where Element: Equatable {
  func isTop(_ item: Element) -> Bool {
      guard let topItem = items.last else {
          return false
      }
      return topItem == item
  }
}

使用guard进行判断，不存在时直接返回假

泛型脚本

extension Container {
  subscript<Indices: Sequence>(indices: Indices) -> [Item]
      where Indices.Iterator.Element == Int {
          var result = [Item]()
          for index in indices {
              result.append(self[index])
          }
          return result
  }
}

传入类型参数名为Indices遵循Sequence协议，且其中的每个元素都为Int类型

var stackOfInts = Stack<Int>()
stackOfInts.push(1)
stackOfInts.push(2)
stackOfInts.push(3)
stackOfInts.push(4)
var aArray = [0,3]
print(stackOfInts[aArray])

实现传入index数组，传入array中Item数组