Go语言精进之路读书笔记第21条——让自己习惯于函数是"一等公民"

21.1 什么是"一等公民"

(1) 正常创建

// $GOROOT/src/fmt/print.go
func newPrinter() *pp {
    p := ppFree.Get().(*pp)
    p.panicking = false
    p.erroring = false
    p.wrapErrs = false
    p.fmt.init(&p.buf)
    return p
}

(2) 在函数内创建，定义匿名函数赋值给变量

// $GOROOT/src/runtime/print.go
func hexdumpWords(p, end uintptr, mark func(uintptr) byte) {
    p1 := func(x uintptr) {
        var buf [2 * sys.PtrSize]byte
        for i := len(buf) - 1; i >= 0; i-- {
            if x&0xF < 10 {
                buf[i] = byte(x&0xF) + '0'
            } else {
                buf[i] = byte(x&0xF) - 10 + 'a'
            }
            x >>= 4
        }
        gwrite(buf[:])
    }
    ...
}

(3) 作为类型

// $GOROOT/src/net/http/server.go
type HandlerFunc func(ResponseWrite, *Request)

(4) 存储到变量中，可以将定义好的函数存储到一个变量中

// $GOROOT/src/runtime/vdso_linux.go
func vdsoParseSymbols(info *vdsoInfo, version int32) {
    ...
    apply := func(symIndex uint32, k vdsoSymbolKey) bool {
        sym := &info.symtab[symIndex]
        typ := _ELF_ST_TYPE(sym.st_info)
        bind := _ELF_ST_BIND(sym.st_info)
        ...
        *k.ptr = info.loadOffset + uintptr(sym.st_value)
        return true
    }
    ...
}

(5) 作为参数传入函数

// $GOROOT/src/time/sleep.go
func AfterFunc(d Duration, f func()) *Timer {
    t := &Timer{
        r: runtimeTimer{
            when: when(d),
            f:    goFunc,
            arg:  f,
        },
    }
    startTimer(&t.r)
    return t
}

(6) 作为返回值从函数返回

// $GOROOT/src/strings/strings.go
func makeCutsetFunc(cutset string) func(rune) bool {
    if len(cutset) == 1 && cutset[0] < utf8.RuneSelf {
        return func(r rune) bool {
            return r == rune(cutset[0])
        }
    }
    if as, isASCII := makeASCIISet(cutset); isASCII {
        return func(r rune) bool {
            return r < utf8.RuneSelf && as.contains(byte(r))
        }
    }
    return func(r rune) bool { return IndexRune(cutset, r) >= 0 }
}

除了上面那些例子，函数还可以被放入数组、切片或map等结构中，可以被赋值给interface{}，可以建立元素为函数的channel

21.2 函数作为"一等公民"的特殊运用

1.像对整型变量那样对函数进行显式类型转换

func greeting(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome, Gopher!\n")
}

func main() {
    http.ListenAndServe(":8080", http.HandlerFunc(greeting))
    //http.ListenAndServe(":8080", greeting)
}

// $GOROOT/src/net/http/server.go
func ListenAndServe(addr string, handler Handler) error {
    server := &Server{Addr: addr, Handler: handler}
    return server.ListenAndServe()
}

...

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

...

type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP调用f(w, r)
func (f HandlerFunc) ServeHttp(w ResponseWriter, r *Request) {
    f(w, r)
}

之所以http.HandlerFunc(greeting)可以通过编译器检查，是因为HandlerFunc的底层类型是func(ResponseWriter, *Request)，与greeting的原型是一致的

2.函数式编程

(1) 柯里化函数

函数柯里化（currying）是把接受多个参数的函数变换成接受一个单一参数（原函数的第一个参数）的函数，并返回接受余下的参数和返回结果的新函数的技术。

闭包是在函数内部定义的匿名函数，并且允许该匿名函数访问定义它的外部函数的作用域

(2) 函子（functor）

函子需要满足两个条件：

• 函子本身是一个容器类型，以Go语言为例，这个容器可以是切片、map甚至channel；
• 该容器类型需要实现一个方法，该方法接受一个函数类型参数，并在容器的每个元素上运用那个函数，得到一个新函子，原函子容器内部的元素值不受影响

函子非常适合用来对容器集合元素进行批量同构处理，而且代码也比每次都对容器中的元素进行循环处理要优雅、简洁需要多。
还需要Go对泛型提供支持，否则就要为每一种容器类型都实现一套对应的Functor机制。

(3) 延续传递式（Continuation-passing Style，CPS）

在CPS风格中，函数是不允许有返回值的。一个函数A应该将其想返回的值显式传给一个continuation函数（一般接受一个参数），而这个continuation函数自身是函数A的一个参数。

CPS需要语言支持尾递归优化，避免代码执行效率不高的问题