高阶函数
在Swift中，函数可做为“一等公民”的存在，也就意味着，我们可以和使用 int 以及 String 一样，将函数当做 参数、值、类型来使用。
其中，将函数当作一个参数和值来使用可见下：
typealias addTwoInts = (Int,Int)->(Int)
var funcType = addTwoInts.self
func aAddb(a:Int,b:Int) -> Int {
return a+b
}
func addFunc(_ add:addTwoInts,_ a:Int,_ b:Int) -> Int {
return add(a,b)
}
//调用
self.addFunc(aAddb, 5, 6) // print --> 11
调用函数 “ self.addFunc(aAddb, 5, 6) ” 时候，aAddb就是一个典型的“值”， 尽管它实际上是一个函数。 与此同时， 它还做为addFunc的参数来使用。
虽然这看起来多此一举，但实际这恰恰体现了高阶函数的特点，牺牲一点点代码的简短，将重点体现在逻辑的清晰上。
一、一个高阶函数的例子
我更喜欢叫下面的这个函数为高阶函数：
var names:[String] = ["61","95","8","248","42"] //一个包含字符串的数组
names = names.sorted { (s1, s2) -> Bool in return s1<s2 }
print(names) -----> ["248", "42", "61", "8", "95"]
这是一个排序函数。不要在意结果并没有按照数字的大小排序，那是因为这是字符串排序，规则将按照首个字母的asc值进行比较。
先看看这个函数的原型：
public func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> [Element]
这个函数显然是将一个 (Element, Element) -> Bool 类型的函数做为他的参数。
一眼看过去，并不是那么好理解，来看下其内部的实现大概是这样的：
extension Array{
typealias IncreasingOrder = (String,String) -> Bool
mutating func mySorted(_ increasingOrder:IncreasingOrder) -> [String] {
var newString:[String] = [String]()
// 假设这里采用简单选择排序
for n in 0..<self.count{
var tamper:String = self[n] as! String
for i in n+1..<self.count { //
var next:String = self[i] as! String
guard !increasingOrder(tamper,next) else {
continue
}
swap(&tamper, &next)
swap(&self[n], &self[i])
}
newString.append(tamper)
}
return newString
}
}
调用：
names = ["61","95","8","248","42"]
names = names.mySorted { (s1, s2) -> Bool in
return s1<s2
}
print(names) -----> ["248", "42", "61", "8", "95"]
这里为了简便， 直接将Element替换成了String，针对String 类型来说，这个函数的功能和系统的Sotred的功能是一样的。 如果需要支持更多的类型，可能要使用到泛型，甚至是where的可选绑定。其实系统的排序已经实现可选绑定式的排序了：重载了sorted函数，根据Element的不同类型，推断是否需要进行可选绑定动作。
通过这个例子，可以看到，所谓的高阶函数，其实就是将一个函数做为另一个函数的参数的语法。这个语法的基础是Swift中的特性：函数的一等公民性质。
我们可以通过这种类型的语法，将类似的函数的内部代码实现隐藏，只根据参数函数的值定义如何执行内部代码。这中方式实现的代码的灵活度将大大的提高。这为在Swift 中写出使用一个函数替代多个同质化的函数提供了一种手段。 当然，做到这种效果可能还需要使用泛型编程。
函数嵌套
大部分情况下，遇到的所有功能都是全局函数，它们在全局范围内定义。如果在函数局部定义一个函数，则称为嵌套函数。
默认情况下，嵌套函数从外部世界隐藏，但在局部仍然可以正常低调用。一个闭包的函数也可以返回一个嵌套函数，以允许在其他范围内使用嵌套函数。
func chooseStepFunction(backward: Bool) -> (Int) -> Int { //全局函数
func stepForward(input: Int) -> Int { return input + 1 } //嵌套函数 1
func stepBackward(input: Int) -> Int { return input - 1 } //嵌套函数 2
return backward ? stepBackward : stepForward //返回一个函数
}
调用：
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
print("\(currentValue)... ") ----> // -4... // -3...// -2...// -1...
currentValue = moveNearerToZero(currentValue) } print("zero!") // zero!
嵌套函数的本质是返回一个函数，之前所说的将函数当作参数基于同一个特性 -- 函数是swift的 一等公民。
同样的道理，一个基本类型的既然能够做为局部的变量来存在，函数为什么不行呢？ 当然可以。这就是局部函数的由来，看来还是基于一等公民的身份啊。 函数嵌套将遵守与基本类型一样的原则，局部的函数，职能够在局部去访问，在外部是没有效果的。
如果我们将嵌套的函数匿名的话，也即是我们下面的这种形式：
typealias adds = (Int)->(Int)
func add(_ c:Int) -> adds {
return { a in
return a + c
}
}
调用：
let addStart = self.add(0) let addTwo = addStart(2) let addFive = addStart(5) print(addTwo) -----> 2 print(addFive) -----> 5
在add函数中，定义了一个起始的数值： 0，返回一个adds类型的函数。 之后我们可以通过给adds类型的实例 addTwo和addFive传递相应的参数即可实现多个函数的套用。
比如，如果我们在做一个以一个起始值做为加减的时候，这中用法就灵活很多，比如，如果我需要以 10做为初始值：
let add = self.add(10) let addTwo = add(2) let addFive = add(5) print(addTwo) ==> 12 print(addFive) --> 15
add已经是另一个函数了。
而实际上，这就函数嵌套的另一种使用，这有很多的叫法 ，我更愿意叫它 -- 柯里化。
柯里化
在计算机科学中，柯里化（Currying）是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数，并且返回接受余下的参数且返回结果的新函数的技术。这个技术由 Christopher Strachey 以逻辑学家 Haskell Curry 命名的，尽管它是 Moses Schnfinkel 和 Gottlob Frege 发明的。
在一般函数中，并不能轻易做到柯里化，可能需要借助其他的方案，比如，将多个参数使用替换成一个struct或者class。
然而高阶函数和嵌套函数却可以很轻易的做到，并保证代码的逻辑清晰。然而为什么要使用柯里化，可以阅读这个文章。 私人觉得，柯里化的优势是去同质化的代码 以及 注重函数的实现减少参数的干扰，简洁提升逻辑。上面的例子刚好解释了柯里化的使用。