go语法的一致性很完美。

[]int{}, map[int]int{} struct{}{} 它们都是由type + literal的形式构成。
所以，func (x, y int) int {} 也是function type + function literal的形式。
上面的表达式返回已声明并初始化的变量。所以foo := func (x, y int) int {} 就构成了所谓的匿名变量。
func Foo(x, y int) int{} 更像是给定义的函数常量，因为Foo不能再被赋予其它值了。

既然是一等公民，可以声明为变量，那么变量之间就可以比较。

针对第一个问题，做了下实验，发现如果改变数组中的元素时是不会改变源数组的，当改变数组中的切片中的元素时是会改变源数组的，我猜是因为切片改变元素时底层数组会改变，所以源数组也跟着改变

package main

import "fmt"

func main() {
    complexArray1 := [3][]string{
        []string{"d", "e", "f"},
        []string{"g", "h", "i"},
        []string{"j", "k", "l"},
    }

    fmt.Printf("The array: %v\n", complexArray1)
    array2 := modifyArray(complexArray1)
    fmt.Printf("The modified array: %v\n", array2)
    fmt.Printf("The original array: %v\n", complexArray1)
    array3 := modifyArray1(complexArray1)
    fmt.Printf("The modified array: %v\n", array3)
    fmt.Printf("The original array: %v\n", complexArray1)
}

func modifyArray(a [3][]string) [3][]string {
    a[1] = []string{"d", "e", "p"}
    return a
}

func modifyArray1(a [3][]string) [3][]string {
    a[1][1] = "v"
    return a
}

第一道题，显然是不会造成原来内容的修改呀
package main

import "fmt"

func main(){
    complexArray := [3][]string{
        []string{"d", "s", "f"},
        []string{"a", "b", "c"},
        []string{"e", "g", "h"},
    }
    tryTest(complexArray)
    fmt.Println(complexArray)
}


func tryTest(array [3][]string){
    array[1] = []string{"1", "2", "3"}
    return
}
输出：
[[d s f] [a b c] [e g h]]

总结
函数不仅能够封装代码，分割功能，解耦逻辑；还可以化身为普通的值，在函数之间传递，赋予变量，判断转换等
函数值可以成为能够被随意传播的独立逻辑组件（功能模块）
只要两个函数的参数列表和结果列表元素顺序及类型是一致的，我们就说他们是一样的函数（实现了相同函数类型的函数）
函数类型是引用类型
高姐函数： 把函数作为参数值传递 或者 函数的返回值是一个函数

改变数组中切片的某个元素的话, 原来的数组值会影响原值 .代码如下

func TestComplexAreray(t *testing.T) {

    complexArray := [3][]string{
        []string{"d", "e", "f"},
        []string{"g", "h", "i"},
        []string{"j", "k", "l"},
    }
    ComplexAreray(complexArray)
    t.Log(complexArray)
}

func ComplexAreray(array [3][]string) {
    for _, v := range array {
        v[0] = "aaa"
    }
    return
}
‘
输出为 : [[aaa e f] [aaa h i] [aaa k l]]

genCalculator 的实现如下

type operate func(x, y int) int
type calculator func(x, y int) (int, error)

func genCalculator(op operate) calculator {
    return func(x, y int) (int, error) {
        if op == nil {
            return 0, errors.New("Invalid operation")
        }
        return op(x, y), nil
    }

}
func TestFunc(t *testing.T) {
    op := func(x, y int) int {
        return x + y
    }
    add := genCalculator(op)
    x, y := 56, 78
    result, err := add(x, y)
    fmt.Printf("The result: %d (error: %v)\n", result, err)
}