import (
  "fmt"
  "math/rand"
)

func <函数名>([param1 Type, [param2, Type, ...]) <返回值类型> {
  <函数体>
}

func add(x int, y int) int {
  return x + y
}

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}

var (
	ToBe   bool       = false
	MaxInt uint64     = 1<<64 - 1
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

// File represents an open file descriptor.
type File struct {
	*file // os specific
}

type Wheel {
  Radius int
}

type engine {
  Power int
}

type Car {
  Wheel
  engine
}

[3]bool{true, true, false}

[]bool{true, true, false}

func append(s []T, vs ...T) []T

for index, value := range array {

}

type Vertex struct {
	Lat, Long float64
}

var m = map[string]Vertex{
	"Bell Labs": Vertex{
		40.68433, -74.39967,
	},
	"Google": Vertex{
		37.42202, -122.08408,
	},
}

//也可以
var m = map[string]Vertex{
	"Bell Labs": {40.68433, -74.39967},
	"Google":    {37.42202, -122.08408},
}

m[key] = elem

elem, ok = m[key]

delete(m, key)

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK

type <接口名> interface {
  <方法名>(<参数列表>) <返回值列表>
  ...
}

value, ok := i.(T)

switch v := i.(type) {
case T:
    //v是T类型的
case S:
    //v是S类型的
default:
    //v不是case所列出来的类型的
}

type Stringer interface {
    String() string
}

type error interface {
    Error() string
}

ch <- v    // 发送v的值到通道ch
v := <-ch  // 从通道ch接收值，并赋给变量v

ch := make(chan int)

ch := make(chan int, 100)

v, ok := <-ch

select {
case c <- x://c的接收端准备好时运行
  x, y = y, x+y
case <-quit://quit有数据发送来时运行
  fmt.Println("quit")
  return
}

func FanIn(chan1, chan2 chan int) chan int {
    c := make(chan int)
    select {
    case a := <-chan1:
        c <- a
    case b := <-chan2:
        c <- b
    }
    return c
}

func FanInMore(chans ...chan int) chan int {
    if len(chans) == 1 {
        return chans[0]
    }

    var c = FanIn(chans[0], chans[1])

    for i := 2; i < len(chans); i++ {
        c = FanIn(c, chans[i])
    }

    return c
}

func mirroredQuery() string {
  responses := make(chan string)
  go func() { responses <- request("asia.gopl.io") }()
  go func() { responses <- request("europe.gopl.io") }()
  go func() { responses <- request("america.gopl.io") }()
  return <- responses
}

panic("Checking goroutines")

done := make(chan struct{})
// 完成时
done <- struct{}{}

type Kind uint

const (
        Invalid Kind = iota
        Bool
        Int
        Int8
        Int16
        Int32
        Int64
        Uint
        Uint8
        Uint16
        Uint32
        Uint64
        Uintptr
        Float32
        Float64
        Complex64
        Complex128
        Array
        Chan
        Func
        Interface
        Map
        Ptr
        Slice
        String
        Struct
        UnsafePointer
)

// Align returns the alignment in bytes of a value of
// this type when allocated in memory.
// 通用对齐字节值，具体看对齐值小节
Align() int

// FieldAlign returns the alignment in bytes of a value of
// this type when used as a field in a struct.
// 字段对齐字节值
FieldAlign() int

// Method returns the i'th method in the type's method set.
// It panics if i is not in the range [0, NumMethod()).
//
// For a non-interface type T or *T, the returned Method's Type and Func
// fields describe a function whose first argument is the receiver.
//
// For an interface type, the returned Method's Type field gives the
// method signature, without a receiver, and the Func field is nil.
// 返回第i个方法，若i超出NumMethod，则会panic
// 若类型不是接口，则返回该类型（指针或值类型）的Method，其Type和Func字段都描述了Method，该Method的第一个参数是类型接收者。
// 若类型是接口，则返回的Method的Type字段，包含了方法签名，而Func则是nil
Method(int) Method

// MethodByName returns the method with that name in the type's
// method set and a boolean indicating if the method was found.
//
// For a non-interface type T or *T, the returned Method's Type and Func
// fields describe a function whose first argument is the receiver.
//
// For an interface type, the returned Method's Type field gives the
// method signature, without a receiver, and the Func field is nil.
// 根据名称获取方法
MethodByName(string) (Method, bool)

// NumMethod returns the number of exported methods in the type's method set.
// 获取方法的总数
NumMethod() int

// Name returns the type's name within its package.
// It returns an empty string for unnamed types.
// 返回本类型的名字
Name() string

// PkgPath returns a named type's package path, that is, the import path
// that uniquely identifies the package, such as "encoding/base64".
// If the type was predeclared (string, error) or unnamed (*T, struct{}, []int),
// the package path will be the empty string.
// 返回本类型的包路径
PkgPath() string

// Size returns the number of bytes needed to store
// a value of the given type; it is analogous to unsafe.Sizeof.
// 指定存储该类型值时所需要的内存空间的字节大小
Size() uintptr

// String returns a string representation of the type.
// The string representation may use shortened package names
// (e.g., base64 instead of "encoding/base64") and is not
// guaranteed to be unique among types. To test for type identity,
// compare the Types directly.
// 返回该Type的字符串表示。该表示会使用缩短的包名，因此不推荐用于类型比较，直接使用`==`比较即可。
String() string

// Kind returns the specific kind of this type.
// 返回这个Type的种类
Kind() Kind

// Implements reports whether the type implements the interface type u.
// 返回该Type是否实现了u接口类型
Implements(u Type) bool

// AssignableTo reports whether a value of the type is assignable to type u.
// 返回该Type是否能够赋值给u类型
AssignableTo(u Type) bool

// ConvertibleTo reports whether a value of the type is convertible to type u.
// 返回该Type是否能够转换为u类型
ConvertibleTo(u Type) bool

// Comparable reports whether values of this type are comparable.
// 返回该Type所存储的值是否能够用于比较
Comparable() bool

// Bits returns the size of the type in bits.
// It panics if the type's Kind is not one of the
// sized or unsized Int, Uint, Float, or Complex kinds.
// Int、Uint、Float或这复杂类型可调用
// 返回以位来衡量的类型的大小。
Bits() int

// ChanDir returns a channel type's direction.
// It panics if the type's Kind is not Chan.
// 通道种类的类型可调用
// Chandir返回通道类型的方向。
ChanDir() ChanDir

// Elem returns a type's element type.
// It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.
// 数组、通道、Map、片段以及指针可调用
// 返回类型所包含的元素的类型，只有
Elem() Type

// Key returns a map type's key type.
// It panics if the type's Kind is not Map.
// Map种类的类型可以调用
// 返回键的类型
Key() Type

// Len returns an array type's length.
// It panics if the type's Kind is not Array.
// 数组种类的类型可以调用
// 返回数组的长度
Len() int

// IsVariadic reports whether a function type's final input parameter
// is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the parameter's
// implicit actual type []T.
//
// For concreteness, if t represents func(x int, y ... float64), then
//
//	t.NumIn() == 2
//	t.In(0) is the reflect.Type for "int"
//	t.In(1) is the reflect.Type for "[]float64"
//	t.IsVariadic() == true
//
// IsVariadic panics if the type's Kind is not Func.
// Func种类的类型可调用
// 返回某个方法的最后参数是不是变长参数。若是，则t.In(t.NumIn() - 1)返回参数的类型为[]T。
IsVariadic() bool

// In returns the type of a function type's i'th input parameter.
// It panics if the type's Kind is not Func.
// It panics if i is not in the range [0, NumIn()).
// 函数种类的类型可以调用
// 返回第i个参数的类型，i在[0, NumIn())范围。
In(i int) Type

// NumIn returns a function type's input parameter count.
// It panics if the type's Kind is not Func.
// 函数类类型调用
// 返回参数数量
NumIn() int

// NumOut returns a function type's output parameter count.
// It panics if the type's Kind is not Func.
// 函数类类型可调用
// 返回返回值的数量
NumOut() int

// Out returns the type of a function type's i'th output parameter.
// It panics if the type's Kind is not Func.
// It panics if i is not in the range [0, NumOut()).
// 函数类类型调用
// 返回第i个返回值的类型
Out(i int) Type

// Field returns a struct type's i'th field.
// It panics if the type's Kind is not Struct.
// It panics if i is not in the range [0, NumField()).
// 结构种类的类型可以调用
// 返回结构的第i个字段，需在[0, NumField())范围内
Field(i int) StructField

// FieldByIndex returns the nested field corresponding
// to the index sequence. It is equivalent to calling Field
// successively for each index i.
// It panics if the type's Kind is not Struct.
// 结构种类类型可调用
// 返回index数组指定的多个字段
FieldByIndex(index []int) StructField

// FieldByName returns the struct field with the given name
// and a boolean indicating if the field was found.
// 结构种类类型可调用
// 返回结构中名称为name的字段，以及是否找到该字段的布尔值
FieldByName(name string) (StructField, bool)

// FieldByNameFunc returns the struct field with a name
// that satisfies the match function and a boolean indicating if
// the field was found.
//
// FieldByNameFunc considers the fields in the struct itself
// and then the fields in any anonymous structs, in breadth first order,
// stopping at the shallowest nesting depth containing one or more
// fields satisfying the match function. If multiple fields at that depth
// satisfy the match function, they cancel each other
// and FieldByNameFunc returns no match.
// This behavior mirrors Go's handling of name lookup in
// structs containing anonymous fields.
// 返回符合match函数的结构的字段。首先从有名字段开始搜索，然后以深度优先的方法，搜索匿名结构字段，在包含一个或多个符合match函数的字段的最浅嵌套层数停止。若该层的多个字段符合该函数，则会各自抵消，并返回没有符合match的结果。
FieldByNameFunc(match func(string) bool) (StructField, bool)

// NumField returns a struct type's field count.
// It panics if the type's Kind is not Struct.
// 结构种类的类型可以调用
// 返回字段的数量
NumField() int

func ArrayOf(count int, elem Type) Type
func ChanOf(dir ChanDir, t Type) Type
func FuncOf(in, out []Type, variadic bool) Type
func MapOf(key, elem Type) Type
func PtrTo(t Type) Type
func SliceOf(t Type) Type
func StructOf(fields []StructField) Type
func TypeOf(i interface{}) Type

// Append appends the values x to a slice s and returns the resulting slice.
// As in Go, each x's value must be assignable to the slice's element type.
// 将x值加入到s片段值中，返回新的片段。每个x必须能够赋值到s片段中
func Append(s Value, x ...Value) Value

// AppendSlice appends a slice t to a slice s and returns the resulting slice.
// The slices s and t must have the same element type.
// 将片段t添加到片段s后面，返回新的片段。s与t的元素类型必须一致
func AppendSlice(s, t Value) Value

// Indirect returns the value that v points to.
// If v is a nil pointer, Indirect returns a zero Value.
// If v is not a pointer, Indirect returns v.
// 若v是指针，返回指针所指向的值的Value。若v是指针且值为nil，则返回零值。若v不是指针，则返回v
func Indirect(v Value) Value

// MakeChan creates a new channel with the specified type and buffer size.
// 使用指定的Type，构建新的通道，并返回
func MakeChan(typ Type, buffer int) Value

// MakeFunc returns a new function of the given Type that wraps the function fn.
// 使用Type指定的函数类型，并构建函数，下方有详解
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value

// MakeMap creates a new map with the specified type.
// 使用typ构建Map
func MakeMap(typ Type) Value

// MakeMapWithSize creates a new map with the specified type and initial space for approximately n elements.
// 构建Map并指定Map的大小
func MakeMapWithSize(typ Type, n int) Value

// MakeSlice creates a new zero-initialized slice value for the specified slice type, length, and capacity.
// 构建数组片段
func MakeSlice(typ Type, len, cap int) Value

// New returns a Value representing a pointer to a new zero value for the specified type. That is, the returned Value's Type is PtrTo(typ).
// 构建typ所指定的类型的零值的指针，也就是PtrTo(typ)这个Value。
func New(typ Type) Value

// NewAt returns a Value representing a pointer to a value of the specified type, using p as that pointer.
// 构建一个由typ指定的新的零值，并被指针p指向。
func NewAt(typ Type, p unsafe.Pointer) Value

// ValueOf returns a new Value initialized to the concrete value stored in the interface i. ValueOf(nil) returns the zero Value.
// 返回i所指向的值，以Value形式表示
func ValueOf(i interface{}) Value

// 返回typ类型的零值
func Zero(typ Type) Value

func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// swap is the implementation passed to MakeFunc.
	// It must work in terms of reflect.Values so that it is possible
	// to write code without knowing beforehand what the types
	// will be.
  // swap函数交换两个value的位置，并返回。参数是Value数组，因此不需要事先知道参数具体类型。
	swap := func(in []reflect.Value) []reflect.Value {
		return []reflect.Value{in[1], in[0]}
	}

	// makeSwap expects fptr to be a pointer to a nil function.
	// It sets that pointer to a new function created with MakeFunc.
	// When the function is invoked, reflect turns the arguments
	// into Values, calls swap, and then turns swap's result slice
	// into the values returned by the new function.
  // 构建一个使用具体类型作为参数的swap函数，接收一个指向空值的函数指针，该指针描述了具体的函数类型，
  // 构建以后，将会设置该指针的值为构建好的函数，这样就能使用该函数指针调用该函数了。
	makeSwap := func(fptr interface{}) {
		// fptr is a pointer to a function.
		// Obtain the function value itself (likely nil) as a reflect.Value
		// so that we can query its type and then set the value.
		fn := reflect.ValueOf(fptr).Elem()

		// Make a function of the right type.
		v := reflect.MakeFunc(fn.Type(), swap)

		// Assign it to the value fn represents.
		fn.Set(v)
	}

	// Make and call a swap function for ints.
	var intSwap func(int, int) (int, int)
	makeSwap(&intSwap)
	fmt.Println(intSwap(0, 1))

	// Make and call a swap function for float64s.
	var floatSwap func(float64, float64) (float64, float64)
	makeSwap(&floatSwap)
	fmt.Println(floatSwap(2.72, 3.14))

}

err := errors.New("This is a error") // Type error
errPtrValue := reflect.ValueOf(&err) // Type Value Kind Ptr
errValue := errValue.Elem() // Type Value with Kind Interface and Type error

// Addr returns a pointer value representing the address of v. It panics if
// CanAddr() returns false. Addr is typically used to obtain a pointer to a
// struct field or slice element in order to call a method that requires a
// pointer receiver.
// 返回一个Value，值为v的地址
func (v Value) Addr() Value

// CanAddr reports whether the value's address can be obtained with Addr. Such
// values are called addressable. A value is addressable if it is an element of
// a slice, an element of an addressable array, a field of an addressable struct,
// or the result of dereferencing a pointer. If CanAddr returns false, calling
// Addr will panic.
// 返回v是否能够取地址。一个值，如果是片段中的元素，能够取地址的数组中的元素、能够
// 取地址的结构的字段、或者是指针解引用的结果，则该v是能够取地址的。
func (v Value) CanAddr() bool

// CanSet reports whether the value of v can be changed. A Value can be changed
// only if it is addressable and was not obtained by the use of unexported
// struct fields. If CanSet returns false, calling Set or any type-specific
// setter (e.g., SetBool, SetInt) will panic.
// 返回v能否被改变。一个值，只在能够取地址或者不是通过使用结构中未导出的字段获取的话，就能被改变。
func (v Value) CanSet() bool

// Convert returns the value v converted to type t. If the usual Go conversion
// rules do not allow conversion of the value v to type t, Convert panics.
// 转换v为类型t的值，需要符合Go的类型转换规则
func (v Value) Convert(t Type) Value

// 返回能否使用Interface函数
func (v Value) CanInterface() bool

// 以空指针的形式返回该v。若v是结构中未导出的值，将会panic
func (v Value) Interface() (i interface{})

// IsValid reports whether v represents a value. It returns false if v is the
// zero Value. If IsValid returns false, all other methods except String panic.
// Most functions and methods never return an invalid value. If one does, its
// documentation states the conditions explicitly.
// 返回是否有效值，若是零值（zero value），则是无效值
func (v Value) IsValid() bool

// Kind returns v's Kind. If v is the zero Value (IsValid returns false),
// Kind returns Invalid.
// 返回值的种类
func (v Value) Kind() Kind

// Method returns a function value corresponding to v's i'th method. The
// arguments to a Call on the returned function should not include a receiver;
// the returned function will always use v as the receiver. Method panics if i
// is out of range or if v is a nil interface v
// 返回v所拥有的第i个方法的Value。注意v不能是没有赋值的接口。返回的方法都将由v作为接收者。
func (v Value) Method(i int) Value

// 根据方法名获取方法Value。
func (v Value) MethodByName(name string) Value

// NumMethod returns the number of exported methods in the value's method set.
// 返回值的方法集中方法的总数
func (v Value) NumMethod() int

// Bool returns v's underlying value. It panics if v's kind is not Bool.
// 布尔值使用，返回底层的布尔值
func (v Value) Bool() bool

// Bytes returns v's underlying value. It panics if v's underlying value is
// not a slice of bytes.
// 字节数组（[]byte）使用，返回该数组
func (v Value) Bytes() []byte

// Cap returns v's capacity. It panics if v's Kind is not Array, Chan, or Slice.
// 数组、片段和通道可使用，返回v的长度
func (v Value) Cap() int

// Close closes the channel v. It panics if v's Kind is not Chan.
// 关闭v代表的通道
func (v Value) Close()

// Complex returns v's underlying value, as a complex128. It panics if v's Kind is not Complex64 or Complex128
// complex类型使用，返回对应的值
func (v Value) Complex() complex128

// Elem returns the value that the interface v contains or that the pointer v
// points to. It panics if v's Kind is not Interface or Ptr. It returns the
// zero Value if v is nil.
// 接口和指针使用，返回接口v或者指针v所指向的值
func (v Value) Elem() Value

// Float returns v's underlying value, as a float64. It panics if v's Kind is not Float32 or Float64
// 浮点数类型值使用，返回浮点数
func (v Value) Float() float64

// Index returns v's i'th element. It panics if v's Kind is not Array, Slice,
// or String or i is out of range.
// 数组使用，返回第i个元素
func (v Value) Index(i int) Value

// Int returns v's underlying value, as an int64. It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.
// 整型值使用，返回对应的整数
func (v Value) Int() int64

// InterfaceData returns the interface v's value as a uintptr pair. It panics
// if v's Kind is not Interface.
// 接口类型使用，返回接口的数据，即类型和值
func (v Value) InterfaceData() [2]uintptr

// IsNil reports whether its argument v is nil. The argument must be a chan,
// func, interface, map, pointer, or slice value; if it is not, IsNil panics.
// Note that IsNil is not always equivalent to a regular comparison with nil in
// Go. For example, if v was created by calling ValueOf with an uninitialized
// interface variable i, i==nil will be true but v.IsNil will panic as v will
// be the zero Value.
// 通道、函数、接口、map、指针和数组片段类型使用，返回是否是nil值。值得注意的是，`v==nil`与
// IsNil的结果不完全一致，当接口值没有被初始化时，本函数会panic，而`==`则不会
func (v Value) IsNil() bool

// Len returns v's length. It panics if v's Kind is not Array, Chan, Map, Slice,
// or String.
// 数组、通道、字典、片段、字符串使用，返回长度
func (v Value) Len() int

// MapIndex returns the value associated with key in the map v. It panics if
// v's Kind is not Map. It returns the zero Value if key is not found in the map
// or if v represents a nil map. As in Go, the key's value must be assignable
// to the map's key type.
// map使用，返回key对应的值
func (v Value) MapIndex(key Value) Value

// map使用，返回所有的键
func (v Value) MapKeys() []Value

// Call calls the function v with the input arguments in. For example,
// if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]).
// Call panics if v's Kind is not Func. It returns the output results as Values.
// As in Go, each input argument must be assignable to the type of the function's
// corresponding input parameter. If v is a variadic function, Call creates the
// variadic slice parameter itself, copying in the corresponding values.
// 使用Value的各个值调用函数v，并返回。需要确保in的各个元素，一一对应v所代表的函数。若有可变长
// 参数，本函数将会创建一个片段，并复制对应的值。
func (v Value) Call(in []Value) []Value

// CallSlice calls the variadic function v with the input arguments in,
// assigning the slice in[len(in)-1] to v's final variadic argument.
// For example, if len(in) == 3, v.CallSlice(in) represents the Go call v(in[0],
// in[1], in[2]...). CallSlice panics if v's Kind is not Func or if v is not
// variadic. It returns the output results as Values. As in Go, each input
// argument must be assignable to the type of the function's corresponding input
// parameter.
// 使用in，调用变长参数函数v，给in片段的所有元素，赋值给v的变长参数，并返回值。
func (v Value) CallSlice(in []Value) []Value

// Field returns the i'th field of the struct v. It panics if v's Kind is not
// Struct or i is out of range.
// 返回第i个字段
func (v Value) Field(i int) Value

// 这些均与Type的定义相同，只不过是返回具体的值，而不是类型
func (v Value) FieldByIndex(index []int) Value
func (v Value) FieldByName(name string) Value
func (v Value) FieldByNameFunc(match func(string) bool) Value

// NumField returns the number of fields in the struct v. It panics if v's Kind
// is not Struct.
// 返回结构v的字段数量
func (v Value) NumField

func (v Value) OverflowComplex(x complex128) bool
func (v Value) OverflowFloat(x float64) bool
func (v Value) OverflowInt(x int64) bool
func (v Value) OverflowUint(x uint64) bool
func (v Value) Pointer() uintptr
func (v Value) Recv() (x Value, ok bool)
func (v Value) Send(x Value)
func (v Value) Set(x Value)
func (v Value) SetBool(x bool)
func (v Value) SetBytes(x []byte)
func (v Value) SetCap(n int)
func (v Value) SetComplex(x complex128)
func (v Value) SetFloat(x float64)
func (v Value) SetInt(x int64)
func (v Value) SetLen(n int)
func (v Value) SetMapIndex(key, val Value)
func (v Value) SetPointer(x unsafe.Pointer)
func (v Value) SetString(x string)
func (v Value) SetUint(x uint64)
func (v Value) Slice(i, j int) Value
func (v Value) Slice3(i, j, k int) Value
func (v Value) String() string
func (v Value) TryRecv() (x Value, ok bool)
func (v Value) TrySend(x Value) bool
func (v Value) Type() Type
func (v Value) Uint() uint64
func (v Value) UnsafeAddr() uintptr

package name