Type Constraint

<T: Comparable>  array.sorted()

<Element: Equatable> array.contains{$0 != first}

 

structures

struct Queue
     
       {}extension Queue {    func isHomo() -> Bool {        guard let first = elements.first else {
   return true}        return !elements.contains{$0 != first}    }}
     

 

functions

e.g.1

// Comparable: func mid
     
      (array: [T]) -> T? {    guard !array.isEmpty else {
   return nil}    return array.sorted()[(array.count - 1) / 2]}mid(array: [3, 2, 1, 5 ,4])mid(array: ["Shell", "Han", "Vermouth"])
     

e.g.2

func pairs
     
      (from dictionary:[Key: Value]) -> [(Key, Value)] {    return Array(dictionary)}
     

 

protocols

// 定义可加的协议// 类型扩展，使用协议protocol Summable {
   static func +(lhs: Self, rhs: Self) -> Self}extension Int: Summable {}extension Double: Summable {}extension String: Summable {}func add
     
       (x: T, y:T) -> T {    return x + y}let intSum = add(x: 1, y: 2)let doubleSum = add(x: 1.2, y: 2.3)let stringSum = add(x: "Shell", y: " Han")
     

 

enum

enum Result
     
       {    case success(Value), failure(Error)}enum MathError
      
        {    case divisionByZero}func divide(x: Int, by y: Int) -> Result
       
         {    guard y != 0 else {        return .failure(MathError.divisionByZero)    }    return .success(x / y)   }