Go语言函数式编程

一、函数式编程 vs 函数指针
1.函数是一等公民：参数，变量，返回值都可以是函数；
2.高阶函数；
3.函数->闭包

二、“正统”函数式编程
1.不可变性：不能有状态，只有常量和函数
2.函数只能由一个参数

三、闭包
1.局部变量
2.自由变量
Go语言中的闭包示例：

func adder()  func(int) int{
   sum := 0

   return func(v int) int {
      sum += v
      return sum
   }
}

func main() {
   a := adder()
   for i :=0; i < 10; i++ {
      fmt.Printf("0 + 1 + ... + %d = %d \n", i, a(i))
   }
}

python中的闭包示例：

def adder():
sum = 0
def f(value):
nonlocal sum
sum += value
return sum
return f

python原生支持闭包
可以使用__closure__来查看闭包内容

c++中的闭包示例：

auto adder() {
auto sum = 0;
return [=] (int value) mutable {
sum += value;
return sum;
}
}

过去：stl或者boost带有类似库
c++11及以后：支持闭包

java中的闭包示例：

Function<Integer, Integer> adder() {
final Holder<Integer> sum = new Holder<>(0);
return (Integer value) -> {
sum.value += value;
return sum.value;
};
}

1.8以后：使用Function接口和Lambda表达式来创建函数对象
匿名类或Lambda表达式均支持闭包

四、函数式编程示例
1.斐波那契数列

func fibonacci()  func() int{
   a, b := 0, 1

   return func() int {
      a, b = b, a + b
      return a
   }
}
func main() {
   f := fibonacci()

   fmt.Println(f()) // 1
   fmt.Println(f()) // 1
   fmt.Println(f()) // 2
   fmt.Println(f()) // 3
   fmt.Println(f()) // 5
}

2.为函数实现接口

package main

import (
   "bufio"
   "fmt"
   "io"
   "strings"
)

func fibonacci() intGen{
   a, b := 0, 1

   return func() int {
      a, b = b, a + b
      return a
   }
}

type intGen func() int

func (g intGen) Read(p []byte) (n int, err error){
   next := g()
   if next > 1000 {
      return 0, io.EOF
   }
   s := fmt.Sprintf("%d\n", next)
   return strings.NewReader(s).Read(p)
}

func printFileContents(reader io.Reader)  {
   scanner := bufio.NewScanner(reader)

   for scanner.Scan() {
      fmt.Println(scanner.Text())
   }
}
func main() {
   f := fibonacci()
   printFileContents(f)
   printFileContents(f)
   printFileContents(f)
   printFileContents(f)

}

3.使用函数来遍历二叉树

package tree

import "fmt"

type Node struct {
   Value interface{}
   Left, Right *Node

}

func (node *Node) PrintNode() {

   fmt.Println(node.Value)
}

func (node *Node) TraverseTree() {
   node.TraverseFunc(func(node *Node) {
      node.PrintNode()
   })
}

func (node *Node) TraverseFunc(f func(node *Node)){
   if node == nil {
      return
   }
   node.Left.TraverseFunc(f)
   f(node)
   node.Right.TraverseFunc(f)
}

五、go语言闭包的应用
1.更为自然，不需要修饰如何访问自由变量
2.没有Lambda表达式，但是又匿名函数