在日常开发中经常会对接口进行调整用来适应新的变化，这个过程可以说是一种进化。
这里将通过一个例子来说明protocol的定义和进化。
比如我要知道两个整数的乘法，a*b，记为a.times(b)
这样把两个数记为乘数和被乘数，那么这个操作可以通过把a连续加b次即可
func times(_ a: Int, _ b: UInt) -> Int {
return b==0 ? 0 : times(a, b-1) + a
}
现在得到了一个倍数函数，可以计算整数的正整数倍，很好，如果a是double呢，是float呢，是string呢，怎么办，这个能够怎么适应这些变化，我们应该怎么去提取这些公共的变化，如果是double，那么我们可以有：
func times(_ a: Double, _ b: UInt) -> Double {
return b==0 ? 0 : times(a, b-1) + a
}
比较一下这两个函数，除了a和返回值的类型外都是一样的，这种情况下，泛型为我们带来了强大的支持，我们来修改一下
func times<T>(_ a: T, _ b: UInt) -> T {
return b==0 ? 0 : times(a, b-1) + a
//compile error: binary operator '+' cannot be applied to two 'T' operands
}
结果怎样，这段代码给出了几个错误，首先是加法运算符不支持，因为编译器不知道T的类型，无法推断出加法操作，在标准库里面，Int和Double都实现了Numeric都protocol，其中声明了加减乘都操作符，下面修改一下代码
func times<T:Numeric>(_ a: T, _ b: UInt) -> T {
return b==0 ? 0 : times(a, b-1) + a
}
这段代码工作的非常好，所有实现Numeric的类型都可以使用这个函数了
接下来我们可以考虑更多了，比如字符串在python里面有一个乘法操作非常高级，"123"*3=="123123123"，这里我们尝试给String也增加一个times方法，刚才的实现明显就不好使了，因为String明显没有实现Numeric的操作，如何找到一个既能适用于数字，又能适用于String的操作呢，在这个例子里面我们需要一个包含加法操作的类型，但是String不支持，我们尝试自己声明一个
protocol addable {
static func + (lhs: Self, rhs: Self) -> Self
}
extension Int:addable {}
extension String:addable {}
func times<T:addable>(_ a: T, _ b: UInt) -> T {
return b==0 ? 0 : times(a, b-1) + a
//error: result values in '? :' expression have mismatching types 'Int' and 'T'
}
这次的错误比较明显了，因为0不能转换成T，只有Numeric的时候可以，所以这里需要一个零值，对于字符串来讲就是空字符串，这个我们需要加到protocol里面
protocol addableAndZero {
static func + (lhs: Self, rhs: Self) -> Self
static func zero() -> Self
}
extension Int:addableAndZero {
static func zero() -> Int {return 0}
}
extension String:addableAndZero {
static func zero() -> String {return ""}
}
func times<T:addableAndZero>(_ a: T, _ b: UInt) -> T {
return b==0 ? T.zero() : times(a, b-1) + a
}
完美，这下我们可以扩充很多类型了，这个暂时告一个小段落
不过addableAndZero这算什么名字，是不是太奇怪了，是不是要拆分开成两个protocol，从这个名字上来看拆分是合理的，因为and表示两者没有太大关系。
标准化
我们平时研究的很多问题都可能是别人研究过，并形成了标准的方法和概念，我们在思考的问题的时候也要尽量考虑使用标准化的方式，这样的好处是沟通比较方便。比如说23中设计模式就是一种标准化，大家讨论某个模式的时候不用专门把这个模式再讲一遍，这就是标准的作用。
幺半群(monoid)：表示一种集合，其中定义了一种操作和一个幺元，操作可以应用在群中任意两个元素上，并且得到的结果也在群中，操作本身支持结合律，即（a*b)*c = a*(b*c)，幺元也是群中的一个元素，其性质为任意元素和幺元进行操作还等于该元素。
String就是一个标准的幺半群，支持连接操作，幺元为空串，其性质为：
- 任意String连接在一起还是String，也支持结合律，和空字符串连接不变。
整数也是幺半群，支持加法操作，幺元为0（也可定义乘法和1）
c++里的int也是幺半群
swift里面有些不一样，因为大数相加溢出后会报错，也就是不能操作，这里我们暂且不考虑这种情况
这里给出幺半群的定义
protocol monoid {
static func op(_ lhs: Self, _ rhs: Self) -> Self
static func identity() -> Self
}
修改前面的定义
extension Int:monoid {
static func identity() -> Int {return 0}
static func op(_ lhs: Int, _ rhs: Int) -> Int {
return lhs + rhs
}
}
extension String:monoid {
static func identity() -> String {return ""}
static func op(_ lhs: String, _ rhs: String) -> String {
return lhs + rhs
}
}
func times<T:monoid>(_ a: T, _ b: UInt) -> T {
return b==0 ? T.identity() : T.op(times(a, b-1), a)
}
接下来会有神奇的事情发生了，我们把Int的op定义为乘法，identity定义成1
extension Int:monoid {
static func identity() -> Int {return 1}
static func op(_ lhs: Int, _ rhs: Int) -> Int {
return lhs * rhs
}
}
times(2,6) == 64//2^6
我们得到了求幂的功能。
知识扩展
最后给一个斐波那契数列的新算法，原理是矩阵的乘法
根据矩阵相乘的结合率，我们可以不断调用公式（1）来生成下一个斐波那契数，即
如果a=1，b=1，那么方阵求幂后就是
我们简单定义二元矩阵
struct Matrix2 {
let a00 : Int, a01: Int, a10: Int, a11: Int
}
extension Matrix2:monoid {
static func identity() -> Matrix2 {return Matrix2(a00:1, a01:0, a10:0, a11:1)}
static func op(_ lhs: Matrix2, _ rhs: Matrix2) -> Matrix2 {
return Matrix2(
a00: lhs.a00 * rhs.a00 + lhs.a01 * rhs.a10,
a01: lhs.a00 * rhs.a01 + lhs.a01 * rhs.a11,
a10: lhs.a10 * rhs.a00 + lhs.a10 * rhs.a10,
a11: lhs.a10 * rhs.a01 + lhs.a11 * rhs.a11
)
}
}
let kM = Matrix2(a00: 1, a01: 1, a10: 1, a11: 0)
let k10 = times(kM,10)
这样把一些之前看起来无关的一些算法通过monoid概念居然实现了统一，同时我们还可以对times的算法进行一些优化，最简单的优化就是根据
现在因为Matrix满足monoid的定义，并且实现了相关操作，求幂的方法也可以应用之前的算法，让斐波那契的算法复杂度从O(n)降低到了O(logn)。
