函数式编程FP

函数式编程的特点

1.函数式编程 是一种编程规范 也就是如何编写程序的方法论

主要思想  把计算过程尽量分解成一系列可复用函数的调用
主要特征  函数式"第一等公民"
  - 函数与其他数据类型一样的地位 可以赋值给其他变量 也可以作为函数参数

2.函数式编程最早出现在LISP语言 绝大部分的现代化编程语言也对函数式编程做了不同程度的支持

Haskell JavaScript Python Swift Kotlin Scala

3.函数式编程中几个常用的概念

- Higher-Order Funcation Funcation Currying
- Functor Applicative Functor Monad

函数式写法

func add(_ v: Int) -> (Int) -> Int {
    return { $0 + v }
}

let fn = add(3)
print(fn(4),fn(100),fn(3333))

func add(_ v: Int) -> (Int) -> Int {
    return { $0 + v }
}

func sub(_ v: Int) -> (Int) -> Int {
    return { $0 - v }
}

func multiple(_ v: Int) -> (Int) -> Int {
    return { $0 * v }
}

func divide(_ v: Int) -> (Int) -> Int {
    return { $0 / v }
}

func mod(_ v: Int) -> (Int) -> Int {
    return { $0 % v }
}

函数合成

func composite(_ f1: @escaping (Int) -> Int, _ f2: @escaping (Int) -> Int) -> (Int) -> Int{
    return {
        f2(f1($0))
    }
}

let fn = composite(add(3), multiple(5))
print(fn(2))

25

更优的函数合成

infix operator >>> : AdditionPrecedence
func >>>(_ f1: @escaping (Int) -> Int,
         _ f2: @escaping (Int) -> Int) -> (Int) -> Int {
    
    return {
        f2(f1($0))
    }
}
let fn = add(3) >>> multiple(5)
print(fn(2))

泛型函数合成

infix operator >>> : AdditionPrecedence
func >>> <A, B, C>(_ f1: @escaping (A) -> B,
                   _ f2: @escaping (B) -> C) -> (A) -> C {
    
    return {
        f2(f1($0))
    }
}

高阶函数

至少满足下列一个条件的函数

- 接受一个或者多个函数作为输入(map fiter reduce等)
- 返回一个函数

柯里化

将一个接受多参数的函数变换为一系列只接受单个参数的函数叫做柯里化

func add(_ v: Int) -> ((Int) -> ((Int) -> Int)) {
    return {
        a in {
            a + $0 + v
        }
    }
}

print(add(30)(20)(10))

60

泛型柯里化

func add(_ v1: Int, _ v2: Int) -> Int {
    return v1 + v2
}

func currying<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C{
    return { b in
        return { a in
            return fn(a,b)
        }
    }
}

print(currying(add)(20)(10))

30

重载运算符实现柯里化

prefix func ~<A, B, C>(_ fn: @escaping (A, B) -> C) -> (B) -> (A) -> C{
    return { b in{ a in fn(a,b) } }
}
print((~add)(20)(10))

30

函子 Functor

像Array Optional 这样支持map运算的类型 称为函子
func map<T>(_ fn: (Inner) -> T) -> Type<T>     Inner是内部包装的元素
func map<T>(_ fn: (Wrapped) -> T) -> Optional<T>

适用函子 Applicative Functor

支持以下运算 就是适用函子
func pure<A>(_ value: A) -> F<A>
func <*><A, B>(fn: F<A> -> B), value: F<A>) -> F<B>

可选类型是适用函子

列子.png

数组是适用函子

例子.png

单子

对任意一个类型F 如果能支持以下运算 就可以称为一个单子
func pure<A>(_ value: A) -> F<A>
func flatMap<A,B>(_ value: F<A>, _ fn: (A) -> F<B>) -> F<B>

Array Optional 是单子