函数式编程（Functional Prigramming）
函数式编程
- 函数式编程(Functional Prigramming,简称FP)是一种编程范式，也就是如何编写程序的方法论
- 主要思想：把计算过程尽量分解成一系列可服用函数的调用
- 主要特征：函数是"第一等公民"
✅函数与其他数据类型一样的地位，可以赋值给变量，也可以作为函数参数、函数返回值
函数式编程最早出现在LISP语言，绝大部分语言也对函数式编程做了不同程度的支持
函数式编程中几个常用的概念
- Higher-Order Function、Function Currying
- Functor、Applicative Functor、Monad
FP实践
假如要实现以下功能: [(num + 3) * 5 - 1] % 10 / 2 这个过程用函数实现应该怎么做？
☝️第一种：传统写法
var num = 1
func add(_ v1: Int, _ v2: Int) -> Int{
v1 + v2
}
func sub(_ v1: Int, _ v2: Int) -> Int{
v1 - v2
}
func multiple(_ v1: Int, _ v2: Int) -> Int{
v1 * v2
}
func divide(_ v1: Int, _ v2: Int) -> Int{
v1 / v2
}
func mod(_ v1: Int, _ v2: Int) -> Int{
v1 % v2
}
//不仅嵌套多层 且难以理解
divide(mod(sub(multiple(add(num, 3), 5), 1), 10), 2)
✌️第二种写法：
//函数式写法
func fp_add(_ v:Int) -> ((Int) -> Int){
{
$0 + v
}
}
func fp_sub(_ v:Int) -> ((Int) -> Int){
{
$0 - v
}
}
func fp_multiple(_ v:Int) -> ((Int) -> Int){
{
$0 * v
}
}
func fp_divide(_ v:Int) -> ((Int) -> Int){
{
$0 / v
}
}
func fp_mod(_ v:Int) -> ((Int) -> Int){
{
$0 % v
}
}
infix operator >>> : AdditionPrecedence
func >>><A, B, C>(_ f1:@escaping (A) -> B,_ f2:@escaping (B) -> C) -> (A) -> C {
{f2(f1($0))}
}
var fn = fp_add(3)>>>fp_multiple(5)>>>fp_sub(1)>>>fp_mod(1)>>>fp_mod(2)
fn(num)
高阶函数
- 高阶函数至少满足下列一个条件的函数
- 接受一个或多个函数作为输入(map,filter,reduce等)
- 返回一个函数
- FB到处是高阶函数
柯里化(Currying)
- 将一个接受多个参数的函数变换为一系列只接受单个参数的函数
func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
//调用 add(10,20) 顺序:10 + 20
func add(_ v: Int) -> (Int) -> Int { { $0 + v } }
//调用 add(20)(10) 顺序:先创建一个 X + 20 的函数 然后传10
Tip：Array、Optional的map方法接收的参数就是一个柯里化函数
三个数相加函数的Curring如下：
//传统的
func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }
//柯⾥化
//v3 == 30
func add2(_ v3: Int) -> (Int) -> (Int) -> (Int) {
//v2 == 20
return { v2 in
//v1 == 10
return { v1 in
return v3 + v2 + v1
}
}
}
add2(30)(20)(10) //10 + 20 + 30 = 60
- 将函数柯里化
//方法1：定义函数将原函数传入，内部柯里化
func add1(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func add2(_ v1: Int, _ v2: Int, _ v3: Int) -> Int { v1 + v2 + v3 }
func currying<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
{ b in { a in fn(a, b) } }
}
func currying<A, B, C, D>(_ fn: @escaping (A, B, C) -> D) -> (C) -> (B) -> (A) -> D {
{ c in { b in { a in fn(a, b, c) } } }
}
//传入一个函数，将函数柯里化
currying(add1)(20)(10) //add1(10,20) 10 + 20 = 30 20传给b，10传给a
currying(add2)(30)(20)(10) //add2(10,20,30) 10 + 20 + 30 = 60 30传给c，20传给b，10传给a
//自定义运算符
func add(_ v1: Int, _ v2: Int, v3: Int) -> Int{
v1 + v2 + v3
}
prefix func ~<A, B, C, D>(_ fn:@escaping (A, B, C) -> D) -> ((C) -> ((B) ->((A) -> D))){
{ c in { b in { a in fn(a, b, c) } } }
}
(~add)(30)(20)(10)
再次回顾上面的例子(加减乘除):
func add(_ v1: Int, _ v2: Int) -> Int { v1 + v2 }
func sub(_ v1: Int, _ v2: Int) -> Int { v1 - v2 }
func multiple(_ v1: Int, _ v2: Int) -> Int { v1 * v2 }
func divide(_ v1: Int, _ v2: Int) -> Int { v1 / v2 }
func mod(_ v1: Int, _ v2: Int) -> Int { v1 % v2 }
//重载~运算符，将函数柯⾥化
prefix func ~<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C {
{ b in { a in fn(a, b) } }
}
//⾃定义>>>运算符
infix operator >>> : AdditionPrecedence
func >>><A, B, C>(_ f1: @escaping (A) -> B,
_ f2: @escaping (B) -> C) -> (A) -> C {
{ f2(f1($0)) }
}
var num = 1
var fn = (~add)(3) >>> (~multiple)(5) >>> (~sub)(1) >>> (~mod)(10) >>> (~divide)(2)
fn(num) //[(num + 3) * 5 - 1] % 10 / 2
函子(Functor)
我们先看下面这个函数：
func map<T>(_ fn: (Inner) -> T) -> Type<T>
支持如上map运算的类型才能称为函子：
- map运算要支持泛型
- 要求接收一个函数，这个函数把Type内部存放的数据当作参数传进去，返回一个T
- 返回的也是同一种Type<T>类型
因此Array、Optional也支持如上的运算即为函子
// Array<Element>
public func map<T>(_ transform: (Element) -> T) -> Array<T>
// Optional<Wrapped>
public func map<U>(_ transform: (Wrapped) -> U) -> Optional<U>
如何去理解函子：
如上该函子，函子里面包装的是2，对这个函子做+3的操作
函子解包取出里面的2，再将2做+3的操作，得到5，最后再将5又放到盒子里面，形成一个新的函子
如果这个函子是可选类型，那么map就不会调用，那么+3操作就不会执行，如下图
Optional类型
如果是数组，里面存放的是2 4 6，先将2 4 6取出来分别做相应的操作，最后操作的结果再包装成数组
Array类型
适用函子
对任意一个函子F，如果能支持以下运算，该函子就是一个适用函子
func pure<A>(_ value: A) -> F<A> //可以理解为，随便给⼀个值就能返回⾃⼰类型的泛型
func <*><A, B>(fn: F<(A) -> B>, value: F<A>) -> F<B> //可以理解为，给⼀个泛型F<A>和⼀个泛型函数fn，最后返回⼀个泛型B
- Optional是适用函子
func pure<A>(_ value: A) -> A? { value } //满足了上面第一个条件
infix operator <*> : AdditionPrecedence
func <*><A, B>(fn: ((A) -> B)?, value: A?) -> B? { //满足了上面第二个条件
guard let f = fn, let v = value else { return nil }
return f(v)
}
//调用
var value: Int? = 10
var fn: ((Int) -> Int)? = { $0 * 2}
print(fn <*> value as Any) //Optional(20)
如何去理解适用函子：
将需要计算的操作也进行包装
适用函子
- Array是适用函子
func pure<A>(_ value: A) -> [A] { [value] }
infix operator <*> : AdditionPrecedence
func <*><A, B>(fn: [(A) -> B], value: [A]) -> [B] {
var arr: [B] = []
if fn.count == value.count {
for i in fn.startIndex..<fn.endIndex {
arr.append(fn[i](value[I]))
}
}
return arr
}
//调用
print(pure(10)) // [10]
var arr = [{ $0 * 2}, { $0 + 10 }, { $0 - 5 }] <*> [1, 2, 3]
print(arr) // [2, 12, -2]
单子（Monad）
对任意一个类型F，如果能支持以下运算，那么就可以称为是一个单子（Monad）
func pure<A>(_ value: A) -> F<A>
func flatMap<A, B>(_ value: F<A>, _ fn: (A) -> F<B>) -> F<B>
很显然，Array、Optional都是单子
面向协议式编程(Protocol Oriented Programming)
面向协议编程
- 面向协议编程（Protocol Oriented Programming，简称POP），是Swift的一种编程范式
- Swift也是一门面向对象的编程语言（Object Oriented Programming，简称OOP）
- 在Swift开发中，OOP和POP是相辅相成的，任何一方并不能取代另一方
回顾OOP
- OOP的三大特性：封装、继承、多态
继承的经典使用场合：
当多个类（比如A、B、C类）具有很多共性时，可以将这些共性抽取到一个父类中（比如D类），最后A、B、C类继承D类
继承
但是OOP也存在一些不足：如何将 BVC、DVC 的公共方法 run 抽取出来？
如何基于OOP的解决方案？
解决方案：
- 将run方法放到另一个对象A中，然后BVC、DVC拥有对象A属性
- 缺点：多了一些额外的依赖关系
- 将run方法增加到UIViewController分类中
- 缺点：UIViewController会越来越臃肿，而且会影响它的其他所有子类
- 将run方法抽取到新的父类，采用多继承？（OC无法做到，C++支持多继承）
- 缺点：会增加程序设计复杂度，产生菱形继承等问题，需要开发者额外解决
POP解决方案
protocol Runnable {
func run()
}
extension Runnable {
func run() {
print("run")
}
}
class BVC: UIViewController, Runnable {}
class DVC: UITableViewController, Runnable {}
POP的注意点
- 优先考虑创建协议，而不是父类(基类)
- 优先考虑值类型（struct、enum），而不是引用类型（class）
- 巧用协议的扩展功能
- 不要为了面向协议而使用协议
利用协议实现前缀效果
- 值类型
//创建结构体
struct ZQ<Base> {
let base: Base //Base是传⼊的类型
init(_ base: Base) { //base是传⼊的类型的值
self.base = base
}
}
//创建协议，并给协议扩展类型和实例计算属性
protocol ZQCompatible {}
extension ZQCompatible {
static var ll: ZQ<Self>.Type { //获取ZQ<Base>类型属性
get { ZQ<Self>.self }
set {}
}
var ll: ZQ<Self> {
get { ZQ(self) } //获取ZQ<Base>实例属性
set {}
}
}
extension String: ZQCompatible {}
extension NSString: ZQCompatible {}
extension ZQ where Base: ExpressibleByStringLiteral { //遵守这个协议的不是String就是NSString
func numberCount() -> Int {
let string = base as! String
var count = 0
for c in string where ("0"..."9").contains(c) {
count += 1
}
return count
}
static func read(){
print("read")
}
}
//调用
var s1: String = "34DGF443454"
var s2: NSString = "34DGF443454"
var s3: NSMutableString = "34DGF443454"
//类型方法
String.ll.read()//输出：read
print(s1.ll.numberCount())//输出：8
print(s2.ll.numberCount())//输出：8
print(s3.ll.numberCount())//输出：8
- 引用类型
class Person {}
class Student: Person {}
//让Person遵守这个协议，并且给ZQ前缀扩充方法
extension Person: ZQCompatible {}
extension ZQ where Base: Person {
func run() {}
static func test() {}
}
Person.ll.test()
Student.ll.test()
let p = Person()
p.ll.run()
let s = Student()
s.ll.run()
利用协议实现类型判断
- 传入的是数组实例:
func isArray(_ value: Any) -> Bool { value is [Any] }
isArray( [1, 2] ) //true
isArray( ["1", 2] ) //true
isArray( NSArray() ) //true
isArray( NSMutableArray() ) //true
- 传入的是数组类型
protocol ArrayType {}
extension Array: ArrayType {}
extension NSArray: ArrayType {}
func isArrayType(_ type: Any.Type) -> Bool { type is ArrayType.Type }
isArrayType([Int].self) //true
isArrayType([Any].self) //true
isArrayType(NSArray.self) //true
isArrayType(NSMutableArray.self) //true
判断某个类型是否遵守某个协议：
类型.self 即为 ArryType.Type
[Int].self 即为 ArryType.Type
