golang并不是传统的函数式编程语言，但是它支持函数式编程。
这里主要讲闭包的应用。

函数式编程 vs 函数指针

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

“正统”函数式编程

1. 不可变性：不能有状态，只有常量和函数
2. 函数只能有一个参数
3. golang没有以上规定

golang闭包的应用

1. 更为自然，不需要修饰如何访问自由变量
2. 没有lambda表达式，但是有匿名函数

1. 累加器

1.1 functional/adder/adder.go

package main

import "fmt"

func adder() func(int) int {
    sum := 0
    return func(v int) int {
        sum += v
        return sum
    }
}

type iAdder func(int) (int, iAdder)

func adder2(base int) iAdder {
    return func(v int) (int, iAdder) {
        return base + v, adder2(base + v)
    }
}

func main() {
    // a := adder() is trivial and also works.
    a := adder2(0)
    for i := 0; i < 10; i++ {
        var s int
        s, a = a(i)
        fmt.Printf("0 + 1 + ... + %d = %d\n",
            i, s)
    }
}

1.2 Output:

0 + 1 + ... + 0 = 0
0 + 1 + ... + 1 = 1
0 + 1 + ... + 2 = 3
0 + 1 + ... + 3 = 6
0 + 1 + ... + 4 = 10
0 + 1 + ... + 5 = 15
0 + 1 + ... + 6 = 21
0 + 1 + ... + 7 = 28
0 + 1 + ... + 8 = 36
0 + 1 + ... + 9 = 45

2. 实现斐波那契数列

2.1 functional/fib/fib.go:

package fib

// 1, 1, 2, 3, 5, 8, 13, ...
func Fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a+b
        return a
    }
}

2.2 functional/main.go:

package main

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

    "learngo/functional/fib"
)

type intGen func() int

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

    // TODO: incorrect if p is too small!
    return strings.NewReader(s).Read(p)
}

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

    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

func main() {
    var f intGen = fib.Fibonacci()
    printFileContents(f)
}

2.3 Output

1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181
6765