Swift面向协议

利用协议实现前缀效果

定义一个结构体Lee<Base>，用于生成计算属性

 struct Lee<Base> {
     let base: Base
     
     init(_ base: Base) {
         self.base = base
     }
 }

1. 定义一个协议 LeeCompatible
```
protocol LeeCompatible { }
```

给协议 LeeCompatible扩展Lee<Base>计算属性 var lee: Lee<Self>

 extension LeeCompatible {
     var lee: Lee<Self> {
         get { Lee(self) }
         set {}
     }
     static var lee: Lee<Self>.Type {
         get { Lee<Self>.self }
         set { }
     }
 }

1. 给某一个具体的类型（String）使用该协议
```
  extension String: LeeCompatible { }
```

5.给定义的指定Lee<Base>中的Base具体类型，同时扩展该类具体要使用的方法或计算属性

   extension Lee where Base == String {
       var numberCount: Int {
           var count = 0
           let strs = ("0"..."9")
           for c in base where strs.contains(String(c)) {
               count += 1
           }
           return count
       }
   }

6.使用定义好的前缀

   func testLee() {
      let count = "asdf123".lee.numberCount
   }

优点：可以在给类型扩展属性和方法时，多本类的方法不会干扰，或者名称重合，比如在在String中有一个numberCount的计算属性，通过该方式来给String扩展一个numberCount的计算属性，不会对String本类中的numberCount的产生影响

  struct Lee<Base> {
      let base: Base
      
      init(_ base: Base) {
          self.base = base
      }
  }

  protocol LeeCompatible { }

  extension LeeCompatible {
      var lee: Lee<Self> {
          get { Lee(self) }
          set {}
      }
      static var lee: Lee<Self>.Type {
          get { Lee<Self>.self }
          set { }
      }
  }

  extension String: LeeCompatible { }

  extension Lee where Base == String {
      var numberCount: Int {
          var count = 0
          let strs = ("0"..."9")
          for c in base where strs.contains(String(c)) {
              count += 1
          }
          return count
      }
  }

  extension Lee where Base: ExpressibleByStringLiteral {
      var numberCount: Int {
          var count = 0
          let strs = ("0"..."9")
          for c in (base as! String) where strs.contains(String(c)) {
              count += 1
          }
          return count
      }
  }

  func testLee() {
     let count = "asdf123".lee.numberCount
      print(count)
      LeePerson.lee.test()
      LeeStudent.lee.test()
      
      let p = LeePerson()
      p.lee.run()
      
      let s = LeeStudent()
      s.lee.run()
  }

  class LeePerson { }
  class LeeStudent: LeePerson {}
  extension LeePerson: LeeCompatible { }

  extension Lee where Base: LeePerson {
      func run() {}
      static func test() {}
  }

利用协议实现类型判断

     protocol ArrayType { }
     extension Array: ArrayType { }
     extension NSArray: ArrayType { }

     func isArrayType(_ type: Any.Type) -> Bool {
         return type is ArrayType.Type
     }
     isArrayType([Int].self)
     isArrayType([Any].self)
     isArrayType(NSArray.self)
     isArrayType(NSMutableArray.self)