// define a variable with name “variableName” and type "type"
var variableName type
 
var vname1, vname2, vname3 type
 
var variableName type = value

var vname1, vname2, vname3 type = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3

vname1, vname2, vname3 := v1, v2, v3

const constantName = value
// you can assign type of constants if it's necessary
const Pi float32 = 3.1415926

const Pi = 3.1415926
const i = 10000
const MaxThread = 10
const prefix = "astaxie_"

const(
    i = 100
    pi = 3.1415
    prefix = "Go_"
)

var arr [10]int  // an array of type [10]int
arr[0] = 42      // array is 0-based

b := [10]int{1, 2, 3} // define a int array with 10 elements, of which the first three are assigned.

c := [...]int{4, 5, 6} // use `…` to replace the length parameter and Go will calculate it for you.

slice := []byte {'a', 'b', 'c', 'd'}

//slice is not really a dynamic array. It's a reference type. 
//slice points to an underlying array whose declaration is similar to array, but doesn't need length. 
 

var numbers map[string] int
// another way to define map
numbers := make(map[string]int)
numbers["one"] = 1  // assign value by key

//map is disorderly. Everytime you print map you will get different results. 
//map doesn't have a fixed length. It's a reference type just like slice.
//len works for map also. It returns how many keys that map has.

//make does memory allocation for built-in models, such as map, slice, and channel, 
//while new is for types' memory allocation.

type person struct {
    name string
    age int
}

var P person  // p is person type

P.name = "Astaxie"  // assign "Astaxie" to the field 'name' of p
P.age = 25  // assign 25 to field 'age' of p
fmt.Printf("The person's name is %s\n", P.name)  // access field 'name' of p

s := person{name: "Sean", age: 50}

type Skills []string

type Human struct {
    name   string
    age    int
    weight int
}

type Student struct {
    Human     // struct as embedded field
    Skills    // string slice as embedded field
    int       // built-in type as embedded field
    specialty string
}

jane := Student{Human: Human{"Jane", 35, 100}, specialty: "Biology"}

//A method is a function with an implicit first argument, called a receiver.
func (r ReceiverType) funcName(parameters) (results)

type Circle struct {
    radius float64
} 

// method
func (c Circle) Area() float64 {
    return c.radius * c.radius * math.Pi
} 

// method with a pointer receiver
func (c *Circle) SetRadius(r float64) {
    c.radius = f
}

func main() {
    c1 := Circle{10}  
    fmt.Println("Area of c1 is: ", c1.Area()) 
}

//An empty interface does not contain any methods, 
//all types implement an empty interface
var void interface{}

type geometry interface {
    area() float64 
} 

type rect struct {
    width, height float64
}
type circle struct {
    radius float64
} 

func (r rect) area() float64 {
    return r.width * r.height
} 

func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
} 

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5} 
    measure(r)
    measure(c)
}

package math

import "testing"

func TestAverage(t *testing.T) {
  var v float64
  v = Average([]float64{1,2})
  if v != 1.5 {
    t.Error("Expected 1.5, got ", v)
  }
}

$ go test

$ go test -cover

$ go test -cover -coverprofile=c.out
$ go tool cover -html=c.out -o coverage.html 

  // Declaring and initializing.
    var c chan int
    c = make(chan int)
    // or
    c := make(chan int)
    // Sending on a channel.
    c <- 1
    // Receiving from a channel.
    // The "arrow" indicates the direction of data flow.
    value = <-c

func boring(msg string) <-chan string { // Returns receive-only channel of strings.
    c := make(chan string)
    go func() { // We launch the goroutine from inside the function.
        for i := 0; ; i++ {
            c <- fmt.Sprintf("%s %d", msg, i)
            time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
        }
    }()
    return c // Return the channel to the caller.
}

   select {
    case v1 := <-c1:
        fmt.Printf("received %v from c1\n", v1)
    case v2 := <-c2:
        fmt.Printf("received %v from c2\n", v1)
    case c3 <- 23:
        fmt.Printf("sent %v to c3\n", 23)
    default:
        fmt.Printf("no one was ready to communicate\n")
    }

build       compile packages and dependencies
clean       remove object files
doc         show documentation for package or symbol
env         print Go environment information
bug         start a bug report
fix         run go tool fix on packages
fmt         run gofmt on package sources
generate    generate Go files by processing source
get         download and install packages and dependencies
install     compile and install packages and dependencies
list        list packages
run         compile and run Go program
test        test packages
tool        run specified go tool
version     print Go version
vet         run go tool vet on packages