the-go-programming-language

package main

import "fmt"

func main() {
        fmt.Println("Hello, 世界")
}

// <===================OUTPUT===================>
// Hello, 世界

$ go run main.go
Hello, 世界

if i < f()                      // wrong
{                               // wrong
        g()
}

$ go get golang.org/x/tools/cmd/goimports

// Echo1 prints its command-line arguments.
package main

import (
        "fmt"
        "os"
)

func main() {
        var s, sep string
        for i := 1; i < len(os.Args); i++ {
                s += sep + os.Args[i]
                sep = " "
        }
        fmt.Println(s)
}

// <===================OUTPUT===================>
// $ go run main.go a b c d   E   f
// a b c d E f

// Echo2 prints its command-line arguments.
package main

import (
        "fmt"
        "os"
)

func main() {
        s, sep := "", ""
        for _, arg := range os.Args[1:] {
                s += sep + arg
                sep = " "
        }
        fmt.Println(s)
}

s := ""
var s string
var s = ""
var s string = ""

// Echo3 prints its command-line arguments.
package main

import (
        "fmt"
        "os"
        "strings"
)

//!+
func main() {
        fmt.Println(strings.Join(os.Args[1:], " "))
}

i309511@ tmp (master) $ cat test.txt
A good idea
Below everage
Below everage
Below everage
Custom Issue
Below everage
Below everage
Custom Issue
Custom Issue
Custom Issue
A good idea
i309511@ tmp (master) $ sort test.txt
A good idea
A good idea
Below everage
Below everage
Below everage
Below everage
Below everage
Custom Issue
Custom Issue
Custom Issue
Custom Issue
i309511@ tmp (master) $ uniq test.txt
A good idea
Below everage
Custom Issue
Below everage
Custom Issue
A good idea
i309511@ tmp (master) $ sort test.txt | uniq
A good idea
Below everage
Custom Issue
i309511@ tmp (master) $ sort test.txt | uniq -c
   2 A good idea
   5 Below everage
   4 Custom Issue

// Dup1 prints the text of each line that appears more than
// once in the standard input, preceded by its count.
package main

import (
        "bufio"
        "fmt"
        "os"
)

func main() {
        counts := make(map[string]int)
        input := bufio.NewScanner(os.Stdin)
        for input.Scan() {
                counts[input.Text()]++
        }
        // NOTE: ignoring potential errors from input.Err()
        for line, n := range counts {
                if n > 1 {
                        fmt.Printf("%d\t%s\n", n, line)
                }
        }
}

// <===================OUTPUT===================>
// go run main.go
// hello
// hello
// world
// world
// world
// we
// 2       hello
// 3       world

// Dup2 prints the count and text of lines that appear more than once
// in the input. It reads from stdin or from a list of named files
package main

import(
        "bufio"
        "fmt"
        "os"
)

func main() {
        counts := make(map[string]int)
        files := os.Args[1:]

        if len(files) == 0 {
                countLines(os.Stdin, counts)
        } else {
                for _, arg := range files {
                        f, err := os.Open(arg)
                        if err != nil {
                                fmt.Fprintf(os.Stderr, "dup2: %v\n", err)
                                continue
                        }
                        countLines(f, counts)
                        f.Close()
                }
        }
        for line, n := range counts {
                if n > 1 {
                        fmt.Printf("%d\t%s\n", n, line)
                }
        }
}

func countLines(f *os.File, counts map[string]int) {
        input := bufio.NewScanner(f)
        for input.Scan() {
                counts[input.Text()]++
        }
        // NOTE: ignoring potential errors from input.Err()
}

// Dup3 prints the count and text of lines that appear more than once
// in the named input files.
package main

import (
        "fmt"
        "io/ioutil"
        "os"
        "strings"
)

func main() {
        counts := make(map[string]int)
        for _, filename := range os.Args[1:] {
                data, err := ioutil.ReadFile(filename)
                if err != nil {
                        fmt.Fprintf(os.Stderr, "dup3: %v\n", err)
                        continue
                }
                for _, line := range strings.Split(string(data), "\n") {
                        counts[line]++
                }
        }
        for line, n := range counts {
                if n > 1 {
                        fmt.Printf("%d\t%s\n", n, line)
                }
        }
}

// Lissajous generates GIF animations of random Lissajous figures.
package main

import (
        "image"
        "image/color"
        "image/gif"
        "io"
        "math"
        "math/rand"
        "os"
)

//!-main
// Packages not needed by version in book.
import (
        "log"
        "net/http"
        "time"
)

//!+main

var palette = []color.Color{color.White, color.Black}

const (
        whiteIndex = 0 // first color in palette
        blackIndex = 1 // next color in palette
)

func main() {
        //!-main
        // The sequence of images is deterministic unless we seed
        // the pseudo-random number generator using the current time.
        // Thanks to Randall McPherson for pointing out the omission.
        rand.Seed(time.Now().UTC().UnixNano())

        if len(os.Args) > 1 && os.Args[1] == "web" {
                //!+http
                handler := func(w http.ResponseWriter, r *http.Request) {
                        lissajous(w)
                }
                http.HandleFunc("/", handler)
                //!-http
                log.Fatal(http.ListenAndServe("localhost:8000", nil))
                return
        }
        //!+main
        lissajous(os.Stdout)
}

func lissajous(out io.Writer) {
        const (
                cycles  = 5     // number of complete x oscillator revolutions
                res     = 0.001 // angular resolution
                size    = 100   // image canvas covers [-size..+size]
                nframes = 64    // number of animation frames
                delay   = 8     // delay between frames in 10ms units
        )
        freq := rand.Float64() * 3.0 // relative frequency of y oscillator
        anim := gif.GIF{LoopCount: nframes}
        phase := 0.0 // phase difference
        for i := 0; i < nframes; i++ {
                rect := image.Rect(0, 0, 2*size+1, 2*size+1)
                img := image.NewPaletted(rect, palette)
                for t := 0.0; t < cycles*2*math.Pi; t += res {
                        x := math.Sin(t)
                        y := math.Sin(t*freq + phase)
                        img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
                                blackIndex)
                }
                phase += 0.1
                anim.Delay = append(anim.Delay, delay)
                anim.Image = append(anim.Image, img)
        }
        gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}

//!-main

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// go run main.go > lissajous.gif                 //
////////////////////////////////////////////////////

// Fetch prints the content found at a URL.
package main

import (
        "fmt"
        "io/ioutil"
        "net/http"
        "os"
)

func main() {
        for _, url := range os.Args[1:] {
                resp, err := http.Get(url)
                if err != nil {
                        fmt.Fprintf(os.Stderr, "fetch: %v\n", err)
                        os.Exit(1)
                }
                b, err := ioutil.ReadAll(resp.Body)
                resp.Body.Close()
                if err != nil {
                        fmt.Fprintf(os.Stderr, "fetch: reading %s: %v\n", url, err)
                        os.Exit(1)
                }
                fmt.Printf("%s", b)
        }
}

//!-

///////////////////////////////////////////////////////////////////////
// <===================OUTPUT===================>                    //
// $ ./fetch http://baidu.com                                        //
// <html>                                                            //
// <meta http-equiv="refresh" content="0;url=http://www.baidu.com/"> //
// </html>                                                           //
///////////////////////////////////////////////////////////////////////

// Fetchall fetches URLs in parallel and reports their times and sizes.
package main

import (
        "fmt"
        "io"
        "io/ioutil"
        "net/http"
        "os"
        "time"
)

func main() {
        start := time.Now()
        ch := make(chan string)
        for _, url := range os.Args[1:] {
                go fetch(url, ch) // start a goroutine
        }
        for range os.Args[1:] {
                fmt.Println(<-ch) // receive from channel ch
        }
        fmt.Printf("%.2fs elapsed\n", time.Since(start).Seconds())
}

func fetch(url string, ch chan<- string) {
        start := time.Now()
        resp, err := http.Get(url)
        if err != nil {
                ch <- fmt.Sprint(err) // send to channel ch
                return
        }

        nbytes, err := io.Copy(ioutil.Discard, resp.Body)
        resp.Body.Close() // don't leak resources
        if err != nil {
                ch <- fmt.Sprintf("while reading %s: %v", url, err)
                return
        }
        secs := time.Since(start).Seconds()
        ch <- fmt.Sprintf("%.2fs  %7d  %s", secs, nbytes, url)
}

//!-

/////////////////////////////////////////////////////////////////////////////////
// <===================OUTPUT===================>                              //
// > go run main.go http://www.baidu.com http://www.bing.com http://www.360.cn //
// 0.21s    61705  http://www.bing.com                                         //
// 0.31s    98409  http://www.baidu.com                                        //
// 0.41s   105174  http://www.360.cn                                           //
// 0.41s elapsed                                                               //
/////////////////////////////////////////////////////////////////////////////////

// Server1 is a minimal "echo" server.
package main

import (
        "fmt"
        "log"
        "net/http"
)

func main() {
        http.HandleFunc("/", handler) // each request calls handler
        log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

// handler echoes the Path component of the request URL r.
func handler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}

// Server2 is a minimal "echo" and counter server.
package main

import (
        "fmt"
        "log"
        "net/http"
        "sync"
)

var mu sync.Mutex
var count int

func main() {
        http.HandleFunc("/", handler)
        http.HandleFunc("/count", counter)
        log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

// handler echoes the Path component of the requested URL.
func handler(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        count++
        mu.Unlock()
        fmt.Fprintf(w, "URL.Path = %q\n", r.URL.Path)
}

// counter echoes the number of calls so far.
func counter(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        fmt.Fprintf(w, "Count %d\n", count)
        mu.Unlock()
}

// Server3 is a minimal "echo" and counter server.
package main

import (
        "fmt"
        "log"
        "net/http"
        "sync"
)

var mu sync.Mutex
var count int

func main() {
        http.HandleFunc("/", handler)
        http.HandleFunc("/count", counter)
        log.Fatal(http.ListenAndServe("localhost:8000", nil))
}

//!+handler
// handler echoes the HTTP request.
func handler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "%s %s %s\n", r.Method, r.URL, r.Proto)
        for k, v := range r.Header {
                fmt.Fprintf(w, "Header[%q] = %q\n", k, v)
        }
        fmt.Fprintf(w, "Host = %q\n", r.Host)
        fmt.Fprintf(w, "RemoteAddr = %q\n", r.RemoteAddr)
        if err := r.ParseForm(); err != nil {
                log.Print(err)
        }
        for k, v := range r.Form {
                fmt.Fprintf(w, "Form[%q] = %q\n", k, v)
        }
}

//!-handler

// counter echoes the number of calls so far.
func counter(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        fmt.Fprintf(w, "Count %d", count)
        mu.Unlock()
}

if err := r.ParseForm(); err != nil {
        log.Print(err)
}

http.HandleFunc("/", func(w http.ResonseWriter, r *http.Request){lissajous(w)})

// Lissajous generates GIF animations of random Lissajous figures.
package main

import (
        "image"
        "image/color"
        "image/gif"
        "io"
        "math"
        "math/rand"
        "os"
)

//!-main
// Packages not needed by version in book.
import (
        "log"
        "net/http"
        "time"
)

//!+main

var palette = []color.Color{color.White, color.Black}

const (
        whiteIndex = 0 // first color in palette
        blackIndex = 1 // next color in palette
)

func main() {
        //!-main
        // The sequence of images is deterministic unless we seed
        // the pseudo-random number generator using the current time.
        // Thanks to Randall McPherson for pointing out the omission.
        rand.Seed(time.Now().UTC().UnixNano())

        if len(os.Args) > 1 && os.Args[1] == "web" {
                //!+http
                handler := func(w http.ResponseWriter, r *http.Request) {
                        lissajous(w)
                }
                http.HandleFunc("/", handler)
                //!-http
                log.Fatal(http.ListenAndServe("localhost:8000", nil))
                return
        }
        //!+main
        lissajous(os.Stdout)
}

func lissajous(out io.Writer) {
        const (
                cycles  = 5     // number of complete x oscillator revolutions
                res     = 0.001 // angular resolution
                size    = 100   // image canvas covers [-size..+size]
                nframes = 64    // number of animation frames
                delay   = 8     // delay between frames in 10ms units
        )
        freq := rand.Float64() * 3.0 // relative frequency of y oscillator
        anim := gif.GIF{LoopCount: nframes}
        phase := 0.0 // phase difference
        for i := 0; i < nframes; i++ {
                rect := image.Rect(0, 0, 2*size+1, 2*size+1)
                img := image.NewPaletted(rect, palette)
                for t := 0.0; t < cycles*2*math.Pi; t += res {
                        x := math.Sin(t)
                        y := math.Sin(t*freq + phase)
                        img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),
                                blackIndex)
                }
                phase += 0.1
                anim.Delay = append(anim.Delay, delay)
                anim.Image = append(anim.Image, img)
        }
        gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors
}

func Siignum(x int) int {
        switch {
        case x > 0:
                return +1
        default:
                return 0
        case x < 0:
                return -1
        }
}

// Boiling prints the boiling point of water.
package main

import "fmt"

const boilingF = 212.0

func main() {
        var f = boilingF
        var c = (f - 32) * 5 / 9
        fmt.Printf("boiling point = %g°F or %g°C\n", f, c)
        // Output:
        // boiling point = 212°F or 100°C
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// boiling point = 212°F or 100°C                 //
////////////////////////////////////////////////////

// Ftoc prints two Fahrenheit-to-Celsius conversions.
package main

import "fmt"

func main() {
        const freezingF, boilingF = 32.0, 212.0
        fmt.Printf("%g°F = %g°C\n", freezingF, fToC(freezingF)) // "32°F = 0°C"
        fmt.Printf("%g°F = %g°C\n", boilingF, fToC(boilingF))   // "212°F = 100°C"
}

func fToC(f float64) float64 {
        return (f - 32) * 5 / 9
}

// <===================OUTPUT===================>
// 32°F = 0°C
// 212°F = 100°C

var s string
fmt.Println(s)                  // ""

var i, j, k int                 // int, int, int
var b, f, s = true, 2.3, "four" // bool, float64, string

var f, err = os.Open(name)      // os.Open returns a file and an error

// Package tempconv performs Celsius and Fahrenheit conversions.
package tempconv

import "fmt"

type Celsius float64
type Fahrenheit float64

const (
        AbsoluteZeroC Celsius = -273.15
        FreezingC     Celsius = 0
        BoilingC      Celsius = 100
)

func (c Celsius) String() string    { return fmt.Sprintf("%g°C", c) }
func (f Fahrenheit) String() string { return fmt.Sprintf("%g°F", f) }

package tempconv

// CToF converts a Celsius temperature to Fahrenheit.
func CToF(c Celsius) Fahrenheit { return Fahrenheit(c*9/5 + 32) }

// FToC converts a Fahrenheit temperature to Celsius.
func FToC(f Fahrenheit) Celsius { return Celsius((f - 32) * 5 / 9) }

package main

import (
        "fmt"
        "os"
)

type Cel float64
type Fah float64

func main() {

        var c Cel = 99.5
        var f Fah = 500.7

        fmt.Printf("%v\n", c)
        fmt.Printf("%g\n", f)

        //////////////////////////////////////////////////////////////////////
        // //invalid operation: c - f (mismatched types Cel and Fah)        //
        // fmt.Printf("%g\n", c-f)                                          //
        //////////////////////////////////////////////////////////////////////

        os.Exit(0)
}

// <===================OUTPUT===================>
// 99.5
// 500.7

package main

import (
        "fmt"
        "os"
)

type Cel float64
type Fah float64

func main() {

        var c Cel
        var f Fah

        fmt.Println(c == 0)
        fmt.Println(f >= 0)
        fmt.Println(c == Cel(f))

        /////////////////////////////////////////////////////////////////////
        // invalid operation: c == f (mismatched types Cel and Fah)        //
        // fmt.Println(c == f)                                             //
        /////////////////////////////////////////////////////////////////////

        os.Exit(0)
}

// <===================OUTPUT===================>
// true
// true
// true

package main

import "fmt"

func f() {}

var g = "g"

func main() {
        f := "f"
        fmt.Println(f)
        fmt.Println(g)
        ////////////////////////////
        // // undefined: h        //
        // fmt.Println(h)         //
        ////////////////////////////
}

// <===================OUTPUT===================>
// f
// g

package main

import "fmt"

func main() {
        x := "hello!" // one

        for i := 0; i < len(x); i++ {
                x := x[i] // two
                if x != '!' {
                        x := x + 'A' - 'a' // three
                        fmt.Printf("%c", x)
                }
        }
}

// <===================OUTPUT===================>
// HELLO

if x := f(); x == 0 {
        fmt.Println(x)
} else if y := g(x); x == y {
        fmt.Println(x, y)
} else {
        fmt.Println(x, y)
}

// compile error: x and y are not visible here
fmt.Println(x, y)

if f, err := os.Open(fname); err != nil { // compile error: unused: f
        return err
}

f.ReadByte()                    // compile error: undefined f
f.Close()                       // compile error: undefined f

f, err := os.Open(fname)
if err != nil {
        return err
}
f.ReadByte()
f.Close()

var cwd string

func init() {
        cwd, err := os.Getwd*() // compile error: unused: cwd
        if err != nil {
                log.Fatalf("os.Getwd failed: %v", err)
        }
}

var cwd string

func init() {
        cwd, err := os.Getwd*() // compile error: unused: cwd
        if err != nil {
                log.Fatalf("os.Getwd failed: %v", err)
        }
        log.Printf("Working directory = %s", cwd)
}

var cwd string

func init() {
        var err error
        cwd, err = os.Getwd()
        if err != nil {
                log.Fataf("os.Getwd failed: %v", err)
        }
}

package main

import "fmt"

func GetTwoComplement(num int8) string {
        var ret = []byte("00000000")

        for i := range ret {
                if ((1 << uint(i)) & uint(num)) > 0 {
                        ret[i] = '1'
                }
        }
        beg := 0
        end := len(ret) - 1
        for beg <= end {
                ret[beg], ret[end] = ret[end], ret[beg]
                beg++
                end--
        }
        return string(ret)
}

func main() {
        for i := 0; i < 8; i++ {
                fmt.Printf("Hex: %d \t\tTwo's complement %s\n", i,
                        GetTwoComplement(int8(i)))
        }

        for i := -121; i >= -128; i-- {
                fmt.Printf("Hex: %d \t\tTwo's complement %s\n", i,
                        GetTwoComplement(int8(i)))
        }

}

// <===================OUTPUT===================>
// Hex: 0               Two's complement 00000000
// Hex: 1               Two's complement 00000001
// Hex: 2               Two's complement 00000010
// Hex: 3               Two's complement 00000011
// Hex: 4               Two's complement 00000100
// Hex: 5               Two's complement 00000101
// Hex: 6               Two's complement 00000110
// Hex: 7               Two's complement 00000111
// Hex: -121            Two's complement 10000111
// Hex: -122            Two's complement 10000110
// Hex: -123            Two's complement 10000101
// Hex: -124            Two's complement 10000100
// Hex: -125            Two's complement 10000011
// Hex: -126            Two's complement 10000010
// Hex: -127            Two's complement 10000001
// Hex: -128            Two's complement 10000000

package main

import "fmt"

func main() {
        fmt.Println(-5 % 3)
        fmt.Println(-5 % 3)
}

// <===================OUTPUT===================>
// -2
// -2

package main

import "fmt"

func main() {
        fmt.Println(5 / 4)
        fmt.Println(5.0 / 4)
        fmt.Println(5 / 4.0)
        fmt.Println(5.0 / 4.0)
}

// <===================OUTPUT===================>
// 1
// 1.25
// 1.25
// 1.25

package main

import "fmt"

func main() {
        var u uint8 = 255
        fmt.Println(u, u+1, u*u)

        var i int8 = 127
        fmt.Println(i, i+1, i*1)
}

// <===================OUTPUT===================>
// 255 0 1
// 127 -128 127

package main

import (
        "fmt"
        "os"
)

func main() {
        medals := []string{"gold", "silver", "bronze"}

        var i uint
        for i = uint(len(medals) - 1); i >= 0; i-- {
                fmt.Println(medals[i])
        }

        fmt.Println()
        os.Exit(0)
}

// <===================OUTPUT===================>
// bronze
// silver
// gold
// panic: runtime error: index out of range

package main

import (
        "fmt"
        "os"
)

func main() {

        var i int
        var u uint
        ////////////////////////////////////////////////////////////////////////
        // // invalid operation: i & u (mismatched types int and uint)        //
        // fmt.Println(i & u)                                                 //
        ////////////////////////////////////////////////////////////////////////
        fmt.Println(uint(i) & u)

        var apples int32 = 1
        var oranges int16 = 2
        //////////////////////////////////////////////////////////////////////////////////////
        // // invalid operation: apples + oranges (mismatched types int32 and int16)        //
        // fmt.Println(apples + oranges)                                                    //
        //////////////////////////////////////////////////////////////////////////////////////
        fmt.Println(int(apples) + int(oranges))
        os.Exit(0)
}

// <===================OUTPUT===================>
// 0
// 3

package main

import (
        "fmt"
        "os"
)

func main() {

        f := 3.14
        i := int(f)
        fmt.Println(f, i)

        f = 1.99
        fmt.Println(int(f))
        os.Exit(0)
}

// <===================OUTPUT===================>
// 3.14 3
// 1

package main

import (
        "fmt"
        "os"
)

func main() {

        f := 1e100
        fmt.Println(f)
        fmt.Println(int(f)) // result is implementation-dependent
        os.Exit(0)
}

// <===================OUTPUT===================>
// 1e+100
// -9223372036854775808

package main

import (
        "fmt"
        "os"
)

func main() {
        o := 0666
        fmt.Printf("%d %[1]o %#[1]o\n", o)

        x := int64(0xdeadbeef)
        fmt.Printf("%d %[1]x %#[1]x %#[1]X\n", x)

        os.Exit(0)
}

// <===================OUTPUT===================>
// 438 666 0666
// 3735928559 deadbeef 0xdeadbeef 0XDEADBEEF

package main

import (
        "fmt"
        "os"
)

func main() {
        ascii := 'a'
        unicode := '国'
        newline := '\n'

        fmt.Printf("%d %[1]c %[1]q\n", ascii)
        fmt.Printf("%d %[1]c %[1]q\n", unicode)
        fmt.Printf("%d %[1]q\n", newline)

        os.Exit(0)
}

// <===================OUTPUT===================>
// 97 a 'a'
// 22269 国 '国'
// 10 '\n'

package main

import "fmt"

func main() {
        var f float32 = (1 << 24)
        fmt.Println(f)
        fmt.Println(f + 1)
        fmt.Println(f == f+1)
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 1.6777216e+07                                  //
// 1.6777216e+07                                  //
// true                                           //
////////////////////////////////////////////////////

const e = 2.171828

package main

import "fmt"

func main() {

        fmt.Printf("%e\n", 1200.00)
        const Avogadro = 6.02214129e23
        const Planck = 6.6206957e-34
        fmt.Println(Avogadro)
        fmt.Println(Planck)
}

// <===================OUTPUT===================>
// 1.200000e+03
// 6.02214129e+23
// 6.6206957e-34

package main

import (
        "fmt"
        "math"
)

func main() {

        fmt.Println("-------Right Align--------------")
        for x := 0; x < 8; x++ {
                fmt.Printf("x = %d ex = %8.3f\n", x, math.Exp(float64(x)))
        }

        fmt.Println("-------Left Align---------------")

        for x := 0; x < 8; x++ {
                fmt.Printf("x = %d ex = %-8.3f\n", x, math.Exp(float64(x)))
        }
}

// <===================OUTPUT===================>
// -------Right Align--------------
// x = 0 ex =    1.000
// x = 1 ex =    2.718
// x = 2 ex =    7.389
// x = 3 ex =   20.086
// x = 4 ex =   54.598
// x = 5 ex =  148.413
// x = 6 ex =  403.429
// x = 7 ex = 1096.633
// -------Left Align---------------
// x = 0 ex = 1.000
// x = 1 ex = 2.718
// x = 2 ex = 7.389
// x = 3 ex = 20.086
// x = 4 ex = 54.598
// x = 5 ex = 148.413
// x = 6 ex = 403.429
// x = 7 ex = 1096.633

package main

import "fmt"

func main() {
        var z float64
        fmt.Println(z, -z, 1/z, -1/z, z/z)
}

// <===================OUTPUT===================>
// 0 -0 +Inf -Inf NaN

package main

import (
        "fmt"
        "math"
)

func main() {
        nan := math.NaN()
        fmt.Println(nan)
        fmt.Println(math.IsNaN(nan), math.IsNaN(0))
        fmt.Println(nan == nan, nan < nan, nan > nan)
}

// <===================OUTPUT===================>
// NaN
// true false
// false false false

func compute() (value float64, ok bool) {
        // ...
        if failed {
                return 0, false
        }
        return result, true
}

package main

import "fmt"

func main() {
        var x complex128 = complex(1, 2) // 1+2i
        var y complex128 = complex(3, 4) // 3+4i

        fmt.Println(x * y)
        fmt.Println(real(x * y))
        fmt.Println(imag(x * y))
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// (-5+10i)                                       //
// -5                                             //
// 10                                             //
////////////////////////////////////////////////////

package main

import "fmt"

func main() {
        fmt.Println(1i * 1i)
}

// <===================OUTPUT===================>
// (-1+0i)

x := 1 + 2i
y := 3 + 4i

package main

import (
        "fmt"
        "math/cmplx"
)

func main() {
        fmt.Println(cmplx.Sqrt(-1))
}

// <===================OUTPUT===================>
// (0+1i)

package main

import "os"

func main() {
        ////////////////////////////////////////////////////////////////////
        // //non-bool 1 (type untyped number) used as if condition        //
        // if 1 {                                                         //
        //      fmt.Println()                                             //
        // }                                                              //
        ////////////////////////////////////////////////////////////////////
        os.Exit(0)
}

s != "" && s[0] == 'x'

if 'a' <= c && c <= 'z' ||
        'A' <= c && c <= 'Z' {
        // ...
}

package main

import (
        "fmt"
        "os"
)

func main() {
        i := 0
        fmt.Println(bool(true))
        ////////////////////////////////////////////////////////
        // // cannot convert i (type int) to type bool        //
        // fmt.Println(bool(i))                               //
        ////////////////////////////////////////////////////////

        t := true
        ////////////////////////////////////////////////////////
        // // cannot convert t (type bool) to type int        //
        // fmt.Println(int(t))                                //
        ////////////////////////////////////////////////////////
        os.Exit(0)
}

package main

import "fmt"

func main() {
        s := "hello, world"
        fmt.Println(len(s))
        fmt.Println(s[0], s[7])
        fmt.Println(s[0:5])
}

////////////////////////////////////////////////////
// <===================OUTPUT===================> //
// 12                                             //
// 104 119                                        //
// hello                                          //
////////////////////////////////////////////////////

c := s[len(s)]                  // panic: index out of range

fmt.Println(s[:5])              // hello
fmt.Println(s[7:])              // world
fmt.Println(s[:])               // hello, world

package main

import (
        "fmt"
        "os"
)

func main() {
        fmt.Println("abcd" == "abcd")
        fmt.Println("abce" > "abcd")
        fmt.Println("abc" > "abcd")
        os.Exit(0)
}

// <===================OUTPUT===================>
// true
// true
// false

s[0] = 'L'                      // compile error: cannot assign to s[0]

package main

import (
        "fmt"
        "os"
)

func main() {
        fmt.Println("abcd" == "abcd")
        fmt.Println("abce" > "abcd")
        fmt.Println("abc" > "abcd")
        os.Exit(0)
}

// <===================OUTPUT===================>
// true
// true
// false

const pi = 3.14159              // approximately: math.Pi is a better approximation

const (
    e = 2.71828
    pi = 3.1415926
)

const IPv4Len = 4

// parseIPv4 parses an IPv4 addresss
func parseIPv4(s string) IP {
        var p [IPv4Len]byte
        // ...
}

package main

import (
        "fmt"
        "os"
        "time"
)

func main() {
        const noDelay time.Duration = 0
        const timeout = 5 * time.Minute
        fmt.Printf("%T %[1]v\n", noDelay)
        fmt.Printf("%T %[1]v\n", timeout)
        fmt.Printf("%T %[1]v\n", time.Minute)

        os.Exit(0)
}

// <===================OUTPUT===================>
// time.Duration 0s
// time.Duration 5m0s
// time.Duration 1m0s

package main

import "fmt"

func main() {
        const (
                a = 1
                b
                c = 2
                d
        )
        fmt.Println(a, b, c, d)
}

// <===================OUTPUT===================>
// 1 1 2 2

var a [3]int                    // array of 3 integers
fmt.Println(a[0])               // print the first element
fmt.Println(a[len(a)-1])        // print the last element, a[2]

package main

import "fmt"

func main() {
        var q [3]int = [3]int{1, 2, 3}
        var r [3]int = [3]int{1, 2}
        fmt.Println(q)
        fmt.Println(r)
}

// <===================OUTPUT===================>
// [1 2 3]
// [1 2 0]

package main

import "fmt"

func main() {
        q := [...]int{1, 2, 3, 4}
        fmt.Println(q)
        fmt.Printf("%T\n", q)
}

// <===================OUTPUT===================>
// [1 2 3 4]
// [4]int

package main

import (
        "fmt"
        "os"
)

func main() {
        q := [3]int{1, 2, 3}
        ///////////////////////////////////////////////////////////////////////////////////
        // //cannot use [4]int literal (type [4]int) as type [3]int in assignment        //
        // q = [4]int{1, 2, 3, 4}                                                        //
        ///////////////////////////////////////////////////////////////////////////////////

        fmt.Println(q)
        os.Exit(0)
}

// <===================OUTPUT===================>
// [1 2 3]

package main

import (
        "fmt"
        "os"
)

func groupDisplay(l int, s string) {

        //////////////////////////////////////////
        // // non-constant array bound l        //
        // foo := [l]string{}                   //
        //////////////////////////////////////////
        ret := make([]string, l) // bytes.Buffer instead of string is better

        for i, c := range s {
                ret[i%l] += string(c)
        }
        fmt.Println(ret)
}

func main() {

        groupDisplay(5, "abcdefghijklmn")
        os.Exit(0)
}

// <===================OUTPUT===================>
// [afk bgl chm din ej]

package main

import "fmt"

func main() {
        symbol := [...]int{9: -1}
        fmt.Println(symbol)
}

// <===================OUTPUT===================>
// [0 0 0 0 0 0 0 0 0 -1]

package main

import "fmt"

func main() {
        a := [2]int{1, 2}
        b := [...]int{1, 2}
        c := [2]int{1, 3}
        fmt.Println(a == b, a == c, b == c)
        d := [3]int{1, 2}
        _ = d
        //////////////////////////////////////////////////////////////////////////////
        // // invalid operation: a == d (mismatched types [2]int and [3]int)        //
        // fmt.Println(a == d)                                                      //
        //////////////////////////////////////////////////////////////////////////////
}

// <===================OUTPUT===================>
// true false false

package main

import (
        "crypto/sha256"
        "fmt"
)

func main() {
        c1 := sha256.Sum256([]byte("x"))
        c2 := sha256.Sum256([]byte("X"))
        fmt.Printf("%x\n%x\n%t\n%T\n", c1, c2, c1 == c2, c1)
}

// <===================OUTPUT===================>
// 2d711642b726b04401627ca9fbac32f5c8530fb1903cc4db02258717921a4881
// 4b68ab3847feda7d6c62c1fbcbeebfa35eab7351ed5e78f4ddadea5df64b8015
// false
// [32]uint8

package main

import (
        "fmt"
        "os"
)

func zero(ptr *[32]byte) {
        for i := range ptr {
                ptr[i] = 0
        }
}
func main() {
        var arr = [32]byte{1, 2, 3, 4}
        fmt.Println(arr)
        zero(&arr)
        fmt.Println(arr)
        os.Exit(0)
}

// <===================OUTPUT===================>
// [1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
// [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

package main

import (
        "fmt"
        "os"
)

func zero(ptr *[32]byte) {
        for i := range *ptr {
                (*ptr)[i] = 0
        }
}
func main() {
        var arr = [32]byte{1, 2, 3, 4}
        fmt.Println(arr)
        zero(&arr)
        fmt.Println(arr)
        os.Exit(0)
}

// <===================OUTPUT===================>
// [1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
// [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

package main

import (
        "fmt"
        "os"
)

func zero(ptr *[32]byte) {
        *ptr = [32]byte{}
}
func main() {
        var arr = [32]byte{1, 2, 3, 4}
        fmt.Println(arr)
        zero(&arr)
        fmt.Println(arr)
        os.Exit(0)
}

// <===================OUTPUT===================>
// [1 2 3 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
// [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]

package main

import (
        "fmt"
        "os"
)

func main() {

        months := [...]string{
                1:  "January",
                2:  "Febrary",
                3:  "March",
                4:  "April",
                5:  "May",
                6:  "June",
                7:  "July",
                8:  "August",
                9:  "September",
                10: "October",
                11: "November",
                12: "December"}

        Q2 := months[4:7]
        summer := months[6:9]

        fmt.Printf("    Q2:  %v len:%d cap:%d\n", Q2, len(Q2), cap(Q2))
        fmt.Printf("summer:  %v len:%d cap:%d\n", summer, len(summer), cap(summer))
        os.Exit(0)
}

// <===================OUTPUT===================>
//     Q2:  [April May June] len:3 cap:9
// summer:  [June July August] len:3 cap:7

fmt.Println(summer[:20])        // panic: out of range
endlessSummer := summer[:5]     // extend a slice(within capacity)
fmt.Println(endlessSummer)      // "[June July August September October]"

package main

import "fmt"

func reverse(s []int) {
        for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
                s[i], s[j] = s[j], s[i]
        }
}

func main() {
        a := [...]int{0, 1, 2, 3, 4, 5}
        reverse(a[:])
        fmt.Println(a)
}

// <===================OUTPUT===================>
// [5 4 3 2 1 0]

package main

import "fmt"

func reverse(s []int) {
        for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
                s[i], s[j] = s[j], s[i]
        }
}

func main() {
        // rotate s by 2
        s := []int{0, 1, 2, 3, 4, 5} // Important! slice is []int type
        reverse(s[:2])
        reverse(s[2:])
        reverse(s)
        fmt.Println(s)
}

// <===================OUTPUT===================>
// [2 3 4 5 0 1]

func equal(x, y []string) bool {
        if len(x) != len(y) {
                return false
        }
        for i := range x {
                if x[i] != y[i] {
                        return false
                }
        }
        return true
}

if summer == nil { /* ... */ }

make([]T, len)
make([]T, len, cap)