$ pwd
dir/helloworld

$ ls
main.go

# ファイル名を指定したbuildはファイル名ままのバイナリ生成
$ go build main.go
$ ls
main    main.go

# ファイル名を指定しないと、ディレクトリ名になる！
$ go build
$ ls
helloworld main       main.go

$ ls
foo.go bar.go

$ cat foo.go 
package main

import "fmt"

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

$ cat bar.go 
package main

import "fmt"

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

$ go build
# github.com/mohira/gopl/ch1/1.1/helloworld
./foo.go:5:6: main redeclared in this block
        previous declaration at ./bar.go:5:6

import "fmt"

package main

func main() {}

$ go build main.go
main.go:1:1: expected 'package', found 'import'

package main

func main() {
	i := 0

	j := i++
}

$ go run main.go 
# command-line-arguments
./main.go:6:9: syntax error: unexpected ++ at end of statement

#include "stdio.h"

int main() {
    int i, j;

    i = 0;

    j = i++;

    printf("i=%d, j=%d\n", i, j); // i=1, j=0
}

$ gcc main.c; ./a.out 
i=1, j=0

package main

import "fmt"

func main() {
	//var x = 1e+9
	//var x int = 1e+9
	//var x float64 = 1e+9

	const x = 1e+9
	//const x int = 1e+9
	//const x float64 = 1e+9

	var a int
	fmt.Println(a + x)

	var b float64
	fmt.Println(b + x)
}

$ go doc ioutil.ReadAll
package ioutil // import "io/ioutil"

func ReadAll(r io.Reader) ([]byte, error)
    ReadAll reads from r until an error or EOF and returns the data it read. A
    successful call returns err == nil, not err == EOF. Because ReadAll is
    defined to read from src until EOF, it does not treat an EOF from Read as an
    error to be reported.

    As of Go 1.16, this function simply calls io.ReadAll.

$ go doc io.ReadAll
package io // import "io"

func ReadAll(r Reader) ([]byte, error)
    ReadAll reads from r until an error or EOF and returns the data it read. A
    successful call returns err == nil, not err == EOF. Because ReadAll is
    defined to read from src until EOF, it does not treat an EOF from Read as an
    error to be reported.

RowLoop:
	for y, row := range rows {
		for x, data := range row {
			if data == endOfRow {
				continue RowLoop
			}
			row[x] = data + bias(x, y)
		}
	}

package main

import "fmt"

// 無限ループになるので注意！
func main() {

// gofmtでも内側にインデントされない！
Hello:
	for i := 0; i < 5; i++ {
		fmt.Println(i)

		if i == 1 {
			continue Hello
		}
	}

GoodBye:
	for j := 1; j < 10; j++ {
		if j %2 == 0 {
			goto Hello // あえてgoto使ってみる
		}

		if j == 9 {
			break GoodBye
		}
	}

}

package main

import "fmt"

func main() {

Name:
	i:=0

	fmt.Println(i)
}

$ go build main.go
./main.go:7:1: label Hello defined and not used

$ go run ch1/1.6/fetchall/main.go https://example.com http://foobarhogefuga.com https://golang.org https://go.pkg.dev https://blog.golang.jp/
Get "http://foobarhogefuga.com": dial tcp: lookup foobarhogefuga.com: no such host
0.42s    9951 https://golang.org
0.52s   86520 https://blog.golang.jp/
0.58s    1256 https://example.com
1.14s  634134 https://go.pkg.dev
1.14s elapsed

package main

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

func main() {
	start := time.Now()
	ch := make(chan string)

	for _, url := range os.Args[1:] {
		go fetch(url, ch)
	}

	for range os.Args[1:] {
		fmt.Println(<-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)
		return
	}

	nbytes, err := io.Copy(io.Discard, resp.Body)
	resp.Body.Close()

	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)
}

package main

func main() {
	break := 123 //  syntax error: unexpected := at end of statement
}

package main

import "fmt"

func main() {
	true := 123
	fmt.Println(true) // 123
}

package main

import "fmt"

func main() {
	int := 123
	fmt.Println(int) // 123

	var x int = 99 //  int is not a type
	fmt.Println(x)
}

package main

import "fmt"

func f() *int {
	v := 1
	return &v
}

var p = f()

// p.35 下段
func main() {
	fmt.Println(p == p)     // true
	fmt.Println(p == f())   // false
	fmt.Println(f() == f()) // false
}

$ find /usr/local/go/src -name 'doc.go'
/usr/local/go/src/cmd/vet/doc.go
/usr/local/go/src/cmd/asm/doc.go
/usr/local/go/src/cmd/go/internal/doc/doc.go
/usr/local/go/src/cmd/trace/doc.go
/usr/local/go/src/cmd/pprof/doc.go
/usr/local/go/src/cmd/dist/doc.go
/usr/local/go/src/cmd/internal/obj/ppc64/doc.go
/usr/local/go/src/cmd/internal/obj/arm64/doc.go
/usr/local/go/src/cmd/pack/doc.go
/usr/local/go/src/cmd/compile/doc.go
/usr/local/go/src/cmd/link/doc.go
/usr/local/go/src/cmd/cgo/doc.go
/usr/local/go/src/cmd/gofmt/doc.go
/usr/local/go/src/cmd/nm/doc.go
/usr/local/go/src/cmd/fix/doc.go
/usr/local/go/src/cmd/buildid/doc.go
/usr/local/go/src/cmd/vendor/golang.org/x/tools/go/analysis/doc.go
/usr/local/go/src/cmd/vendor/golang.org/x/xerrors/doc.go
/usr/local/go/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/doc.go
/usr/local/go/src/cmd/cover/doc.go
/usr/local/go/src/strconv/doc.go
/usr/local/go/src/net/http/doc.go
/usr/local/go/src/go/doc/doc.go
/usr/local/go/src/go/build/doc.go
/usr/local/go/src/regexp/syntax/doc.go
/usr/local/go/src/fmt/doc.go
/usr/local/go/src/runtime/metrics/doc.go
/usr/local/go/src/runtime/race/doc.go
/usr/local/go/src/internal/race/doc.go
/usr/local/go/src/encoding/gob/doc.go
/usr/local/go/src/html/template/doc.go
/usr/local/go/src/math/big/doc.go
/usr/local/go/src/log/syslog/doc.go
/usr/local/go/src/os/signal/doc.go
/usr/local/go/src/text/template/doc.go
/usr/local/go/src/sync/atomic/doc.go

// Exported (global) variable serving as input for some
// of the benchmarks to ensure side-effect free calls
// are not optimized away.
var Input uint64 = DeBruijn64

// Exported (global) variable to store function results
// during benchmarking to ensure side-effect free calls
// are not optimized away.
var Output int

$ go doc math/bits.OnesCount
package bits // import "math/bits"

func OnesCount(x uint) int
    OnesCount returns the number of one bits ("population count") in x.

// --- OnesCount ---

const m0 = 0x5555555555555555 // 01010101 ...
const m1 = 0x3333333333333333 // 00110011 ...
const m2 = 0x0f0f0f0f0f0f0f0f // 00001111 ...
const m3 = 0x00ff00ff00ff00ff // etc.
const m4 = 0x0000ffff0000ffff

// OnesCount returns the number of one bits ("population count") in x.
func OnesCount(x uint) int {
	if UintSize == 32 {
		return OnesCount32(uint32(x))
	}
	return OnesCount64(uint64(x))
}

// OnesCount8 returns the number of one bits ("population count") in x.
func OnesCount8(x uint8) int {
	return int(pop8tab[x])
}

// OnesCount16 returns the number of one bits ("population count") in x.
func OnesCount16(x uint16) int {
	return int(pop8tab[x>>8] + pop8tab[x&0xff])
}

// OnesCount32 returns the number of one bits ("population count") in x.
func OnesCount32(x uint32) int {
	return int(pop8tab[x>>24] + pop8tab[x>>16&0xff] + pop8tab[x>>8&0xff] + pop8tab[x&0xff])
}

// OnesCount64 returns the number of one bits ("population count") in x.
func OnesCount64(x uint64) int {
	// Implementation: Parallel summing of adjacent bits.
	// See "Hacker's Delight", Chap. 5: Counting Bits.
	// The following pattern shows the general approach:
	//
	//   x = x>>1&(m0&m) + x&(m0&m)
	//   x = x>>2&(m1&m) + x&(m1&m)
	//   x = x>>4&(m2&m) + x&(m2&m)
	//   x = x>>8&(m3&m) + x&(m3&m)
	//   x = x>>16&(m4&m) + x&(m4&m)
	//   x = x>>32&(m5&m) + x&(m5&m)
	//   return int(x)
	//
	// Masking (& operations) can be left away when there's no
	// danger that a field's sum will carry over into the next
	// field: Since the result cannot be > 64, 8 bits is enough
	// and we can ignore the masks for the shifts by 8 and up.
	// Per "Hacker's Delight", the first line can be simplified
	// more, but it saves at best one instruction, so we leave
	// it alone for clarity.
	const m = 1<<64 - 1
	x = x>>1&(m0&m) + x&(m0&m)
	x = x>>2&(m1&m) + x&(m1&m)
	x = (x>>4 + x) & (m2 & m)
	x += x >> 8
	x += x >> 16
	x += x >> 32
	return int(x) & (1<<7 - 1)
}

package main

import "fmt"

func main() {
	const x = 1
	var y int
	var z float64
	y = x
	z = x
	fmt.Printf("%T\n", x) // int
	fmt.Printf("%T\n", y) // int
	fmt.Printf("%T\n", z) // float64
}

package main

import "os"

// p.34中段: 宣言 と 代入 は違う！
func main() {
	f, err := os.Open("foo")
	if err != nil {
		panic(err)
	}

	f, err := os.Create("bar") // no new variables on left side of :=

	if err != nil {
		panic(err)
	}
}

package main

import "fmt"

func main() {
	a := 1
	a := 2 // no new variables on left side of :=

	fmt.Println(a)
}

package main

import "fmt"

// ただ多値を返すことを表現するだけの関数
func tuple() (int, int) {
	return 1, 2
}
func main() {
	a, x := tuple()
	a, y := tuple() // a は再宣言、yは新しい識別子なので、コンパイルは通る

	fmt.Println(a, x, y)
}

package main

import "fmt"

func main() {
	// ./main.go:7:6: a redeclared in this block
	//        previous declaration at ./main.go:6:6
	var a = 1
	var a = 2

	fmt.Println(a)
}

package main

import "fmt"

var a = 1

func main() {
	var a = 2

	fmt.Println(a) // 2 <- 1じゃない！
}

package main

import "fmt"

// p.35 中段
func main() {
	var x, y int
	fmt.Println(&x == &x, &x == &y, &x == nil) // true false false
}

package main

import "fmt"

func f() *int {
	v := 1
	return &v
}

var p = f()

// p.35 下段
func main() {
	fmt.Println(p == p)     // true
	fmt.Println(*p == *f()) // true; 値は同じ
	fmt.Println(p == f())   // false; アドレスは違う
	fmt.Println(f() == f()) // false
}

package main

import (
	"flag"
	"fmt"
	"strings"
)


// それぞれポインタ型を返す
var n *bool = flag.Bool("n", false, "omit trailing newline(改行の省略)")
var sep *string = flag.String("s", " ", "separator")


// p.36
func main() {
	flag.Parse()

    fmt.Printf("%T\n", n) // *bool
    fmt.Printf("%T\n", sep) // *string

    fmt.Println(flag.Args())
	fmt.Print(strings.Join(flag.Args(), *sep))

	if !*n {
		fmt.Println()
	}
}

$ go doc builtin.new
package builtin // import "builtin"

func new(Type) *Type
    The new built-in function allocates memory. The first argument is a type,
    not a value, and the value returned is a pointer to a newly allocated zero
    value of that type.

package main

import (
	"fmt"
)

func main() {
	p := new(int)
	fmt.Printf("%T\n", p) // *int
	fmt.Println(p)        // 0xc0000140c8
	fmt.Println(*p)       // 0

	*p = 2
	fmt.Println(*p) // 2
}

package main

import (
	"fmt"
)

func init() {
	fmt.Println("init2")
}

func init() {
	fmt.Println("init1")
}

func init() {
	fmt.Println("init3")
}

func main() {
	fmt.Println("main done")
}

$ go run main.go
init2
init1
init3
main done

package main

import "fmt"

// p.49
// c, a, b の順で評価される == 依存関係をうまいこと解決している
var a = valueA()
var b = valueB()
var c = 1

func valueA() int {
	fmt.Println("call valueA()")
	return b + c
}

func valueB() int {
	fmt.Println("call valueB()")
	return c + 1
}

func main() {
	fmt.Println("main start")
	fmt.Println("main done")
}

$ go run main.go
call valueB()
call valueA()
main start
main done

package main

import "fmt"

// シャドーイング
var x = 1

// [Big Sky :: Go 言語で変数のシャドウイングを避けたいなら shadow を使おう。](https://mattn.kaoriya.net/software/lang/go/20200227102218.htm)
func main() {
	x := 2
	fmt.Println(x)
}

package main

import "fmt"

// p.52: 3つのレキシカルブロック
// Goroutineの i:=i も同じっぽい
// 他の言語とくらべると混乱するやつ
func main() {
	x := "hello!"

	for i := 0; i < len(x); i++ {
		fmt.Printf("i=%d\n", i)
		fmt.Printf("\tfor block: x=%v\n", x) // ループごとに x を「宣言」している！
		x := x[i]                            // 2回めのループでのxはどうなるんだ？
		if x != '!' {
			x := x + 'A' - 'a' // 英小文字 を 英大文字 に変換
			fmt.Printf("\t if block: x=%c\n", x)
		}
	}
}

$ go run main.go
i=0
        for block: x=hello!
         if block: x=H
i=1
        for block: x=hello!
         if block: x=E
i=2
        for block: x=hello!
         if block: x=L
i=3
        for block: x=hello!
         if block: x=L
i=4
        for block: x=hello!
         if block: x=O
i=5
        for block: x=hello!

package main

import "fmt"

// p.52 {}がレキシカルブロックってわけじゃない！
// for文の暗黙のレキシカルブロックを作っている
func main() {
	for i := 1; i <= 5; i++ {
		fmt.Printf("outer: i=%d", i)
		i := i*i
		fmt.Printf(" inner: i=%d\n", i)
	}
}

$ go run main.go
outer: i=1 inner: i=1
outer: i=2 inner: i=4
outer: i=3 inner: i=9
outer: i=4 inner: i=16
outer: i=5 inner: i=25

package main

import "fmt"

func f() int {
	return 0
}

func g(n int) int {
	return 0
}

// p.53
func main() {
	if x := f(); x == 0 {
		fmt.Println(x)
	} else if y := g(x); x == y {
		fmt.Println(x, y)
	} else {
		fmt.Println(x, y)
	}

	fmt.Printf(x, y) // undefined x, y
}

package main

import (
	"fmt"
	"os"
)

func main() {
	if _, err := os.Open("foo"); err != nil {
		panic(err)
	}
	fmt.Println(err) // undefined: err
}

package main

import (
	"log"
	"os"
)

func main() {

	if f, err := os.Open("tmp"); err != nil {
		log.Println(err)
	} else {
		// else句もブロックに含まれるのでセーフ
		f.Stat()
	}

}

package foo

import (
	"log"
	"os"
)

var Cwd string // 実は使われてない！！！ GoLandは警告出してくれるね

func init() {
	Cwd, err := os.Getwd()
	if err != nil {
		log.Fatalf("os.Getwd failed: %v\n", err)
	}
	// ここの Cwd は init()内のレキシカルスコープで「宣言」された Cwd
	// なので、パッケージレベルの変数cwdはゼロ値のまま！
	// なので、他のファイルから Cwd を 利用しようとすると...
	log.Printf("Working directory = %s\n", Cwd)
}

package main

import (
	"fmt"
	"github.com/mohira/gopl/ch2/2.7/7/foo"
)

func main() {
	fmt.Println("main")

	fmt.Println(foo.Cwd=="") // true; つまり foo.Cwdが文字列のゼロ値のまま！
}