func worker(done chan bool) {
	spew.Printf("working...\n")
	time.Sleep(time.Second)
	spew.Printf("done!\n")

	done <- true
}

func main() {
	nums := []int{2, 3, 4}

	// for ... range は for の中で initialize できない。
	sum := 0
	for _, num := range nums {
		sum += num
	}
	spew.Printf("sum: %#+v\n", sum)

	// ちなみにここでも num をまた宣言 & 代入してるけど、これは OK である。
	// 新規 + 既存 := で多値を受け取る場合は、既存変数を再宣言 & 再代入しても
	// エラーにはならない。なお、同一スコープな否ならアドレス番地は同じになっている。
	//  [Go言語で複数戻り値の受け取りで既存変数の再宣言？ - taknb2nchのメモ]
	//  http://d.hatena.ne.jp/taknb2nch/20140819/1408421727
	for i, num := range nums {
		if num == 3 {
			spew.Printf("index: %#+v\n", i)
		}
	}

	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		spew.Printf("%#+v -> %#+v\n", k, v)
	}

	for i, c := range "号号" {
		spew.Printf("%#+v -> %#+v\n", i, c)
	}
}

func main() {
	res := plus(1, 2)
	spew.Printf("1 + 2 = %#+v\n", res)

	res = plusPlus(1, 2, 3)
	spew.Printf("1 + 2 + 3 = %#+v\n", res)
}

func main() {
	c1 := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		c1 <- "result 1"
	}()

	select {
	case res := <-c1:
		spew.Printf("%#+v\n", res)

	case <-time.After(time.Second * 1):
		spew.Printf("timeout 1\n")
	}

	c2 := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		c2 <- "result 2"
	}()

	select {
	case res := <-c2:
		spew.Printf("%#+v\n", res)
	case <-time.After(time.Second * 3):
		spew.Printf("timeout 2\n")
	}
}

func main() {
	timer1 := time.NewTimer(time.Second * 2)
	// Timer 構造体のポインタが返ってくる様子。
	spew.Printf("%#+v\n", timer1)

	// 経過した時の時刻が入るっぽいな。
	ret := <-timer1.C
	spew.Printf("%#+v\n", ret)
	fmt.Println("Timer 1 expired", ret)

	timer2 := time.NewTimer(time.Second)
	go func() {
		<-timer2.C
		fmt.Println("Timer 2 expired")
	}()

	// stop2 := timer2.Stop()
	// if stop2 {
	// 	spew.Printf("%#+v\n", stop2)
	// 	fmt.Println("Timer 2 stopped")
	// }

	// ゴルーチンの終了を待ったら当然結果が出力されるし、
	// timer2 は expired しちゃってるから Stop() も動作しない。
	// time.Sleep(time.Second * 3)
	// こうでよくね。
	if timer2.Stop() {
		fmt.Println("Timer 2 stopped")
	}
}

func main() {

	apiUser := os.Getenv(ApiUser)
	apiKey := os.Getenv(ApiKey)

	id := 12345

	client := slclient.NewSoftLayerClient(apiUser, apiKey)

	virtualGuestService, err := client.GetSoftLayer_Virtual_Guest_Service()

	if err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println("No error found in client.GetSoftLayer_Virtual_Guest_Service()")
	}

	virtualGuest, err := virtualGuestService.GetObject(id)

	if err != nil {
		fmt.Println("errors:", err)
		return
	} else {
		fmt.Println("No error found in virtualGuestService.GetObject(id)")
	}

	spew.Printf("virtualGuest =%#+v\n", virtualGuest)

	vgPowerState, err := virtualGuestService.GetPowerState(id)

	spew.Printf("vgPowerState =%#+v\n", vgPowerState)
}

func sum(nums ...int) {
	spew.Printf("nums: %#+v\n", nums)
	total := 0
	for _, num := range nums {
		total += num
	}
	spew.Printf("total: %#+v\n\n", total)
}

func main() {
	a, b := vals()
	spew.Printf("a: %#+v\n", a)
	spew.Printf("b: %#+v\n", b)

	_, c := vals()
	spew.Printf("c: %#+v\n", c)
}

func main() {
	// int
	var i int = 1
	var pi *int = &i

	// string
	var str string = "hello, world."
	var pstr *string = &str

	// array
	var ary [2]int = [2]int{1, 2}
	var pary *[2]int = &ary

	// slice
	var slc []int = []int{10, 20}
	var pslc *[]int = &slc

	// これは分かる。
	spew.Println("int")
	spew.Printf("i = %#+v, &i = %#+v, pi = %#+v, *pi = %#+v\n\n", i, &i, pi, *pi)

	spew.Println("string")
	spew.Printf("str = %#+v, &str = %#+v, pstr = %#+v, *pstr = %#+v\n\n", str, &str, pstr, *pstr)

	spew.Println("array")
	spew.Printf("ary = %#+v, &ary = %#+v, pary = %#+v, *pary = %#+v\n\n", ary, &ary, pary, *pary)

	spew.Println("slice")
	spew.Printf("slc = %#+v, &slc = %#+v, pslc = %#+v, *pslc = %#+v\n\n", slc, &slc, pslc, *pslc)

	// 解せぬ。
	spew.Println("string[n]")
	// &str[0]: cannot take the address of str[0] // 文字列の要素をアドレス番地 + 添字で求められないのは仕様である、といった感じであろうか？
	// pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // 上と同様。
	// *pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // なぜだ。
	spew.Printf("str[0] = %#+v\n\n", str[0])

	spew.Println("array[n]")
	// *pary[0]: invalid indirect of pary[0] (type int) // なぜだ。
	spew.Printf("ary[0] = %#+v, &ary[0] = %#+v, pary[0] = %#+v\n\n", ary[0], &ary[0], pary[0])

	spew.Println("slice[n]")
	// pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // スライスはそれ自体がすでにどこかのアドレス番地の参照先のはず。スライスのポインタはダブルポインタ的な感じなので、アドレス番地 + 添字で求められないのは仕様である、といった感じだろうか？
	// *pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // なぜだ。
	spew.Printf("slc[0] = %#+v, &slc[0] = %#+v\n\n", slc[0], &slc[0])

	// できるじゃん。
	spew.Println("(*string)[n]")
	spew.Printf("(*pstr)[0] = %#+v\n\n", (*pstr)[0])

	spew.Println("(*array)[n]")
	spew.Printf("(*pary)[0] = %#+v\n\n", (*pary)[0])

	spew.Println("(*pscl)[n]")
	spew.Printf("(*pslc)[0] = %#+v\n\n", (*pslc)[0])
}

func main() {
	messages := make(chan string, 2)

	messages <- "buffered"
	messages <- "channel"

	spew.Printf("%#+v\n", &messages)
	spew.Printf("%#+v\n", <-messages)
	spew.Printf("%#+v\n", <-messages)
}

func main() {
	strs := []string{"c", "a", "b"}
	sort.Strings(strs)
	spew.Printf("Strings: %#+v\n", strs)

	ints := []int{7, 2, 4}
	sort.Ints(ints)
	spew.Printf("Intss: %#+v\n", ints)

	s := sort.IntsAreSorted(ints)
	spew.Printf("Sorted: %#+v\n", s)
}

func main() {
	i := 1
	spew.Printf("initial: %#+v\n", i)

	zeroval(i)
	spew.Printf("zeroval: %#+v\n", i)

	zeroptr(&i)
	spew.Printf("zeroptr: %#+v\n", i)

	spew.Printf("pointer: %#+v\n", &i)
}

func main() {
	//* key / varlue ペアを設定するために、'''os.Setenv''' を使います。key から value を取得するために '''os.Getenv''' を使います。環境に key が存在しない場合は空文字が返ります。
	os.Setenv("FOO", "1")
	spew.Printf("FOO: %#+v\n", os.Getenv("FOO"))
	spew.Printf("BAR: %#+v\n", os.Getenv("BAR"))
	spew.Printf("$PGUSER: %#+v\n", os.Getenv("PGUSER"))

	//* '''os.Environ''' を使うと、環境内の全ての key / value ペアがリストされます。これは '''key=value''' という形式の文字列スライスです。ここで私達は全ての key を出力しています。
	spew.Println()
	for _, e := range os.Environ() {
		pair := strings.Split(e, "=") // e: "key=value" --- strings.Split() ---> pair:["key", "value"]
		spew.Println(pair[0])
	}
}

func getStat() {
	sTime := time.Now()

	defer func() {
		if e := recover(); e != nil {
			statsdIncrement("error")
			logInfo(0, sTime, "Error getting stat: %s", e.(error).Error())
		}
		statsdTiming(sTime, "done")
	}()

	nsInfo, err := asInfo(*cfg.aspk_node, *cfg.asinfo_port)
	if err != nil {
		logInfo(0, sTime, "Error getting node stat: %s", err.Error())
		statsdIncrement("error")
	} else {
		for nsName, nsStat := range *nsInfo {
			for key, val := range *nsStat {
				if *cfg.stdout {
					spew.Printf("%s.%s = %s\n", nsName, key, val)
				}
				if isIn(key, cfg.metric) {
					num, ok := a2i(val)
					if ok {
						statsdGauge(num, "%s.%s", nsName, key)
					}
				}
			}
		}
	}
}

func dumpBloblets(dir *directory, indent int) (int, int64, int64) {
	var numBloblets int = 0
	var totalSize int64 = 0
	var minCompressedSize int64 = math.MaxInt64
	if dir.bloblet != nil {
		cr := compressedSize(dir.bloblet)
		minCompressedSize = cr
		if details {
			fmt.Printf(strings.Repeat(" ", indent))
			spew.Printf("Bloblet @ %s of size %d, compressed size %d\n", dir.bloblet.path, dir.bloblet.size, cr)
		}
		totalSize += dir.bloblet.size
		numBloblets++

	}

	for _, child := range dir.children {
		n, t, c := dumpBloblets(child, indent+2)
		numBloblets += n
		totalSize += t
		if c < minCompressedSize {
			minCompressedSize = c
		}
	}

	return numBloblets, totalSize, minCompressedSize
}

func main() {
	pings := make(chan string, 1)
	pongs := make(chan string, 1)

	ping(pings, "passed message")
	pong(pings, pongs)
	spew.Printf("%#+v\n", <-pongs)
}

func main() {
	s := "sha1 this string"

	//* ハッシュの生成パターンは '''i sha1.New()'''、'''sha1.Write(bytes)'''、'''sha1.Sum([]byte{})''' です。ここでは、私達は新しいハッシュ生成から始めます。
	h := sha1.New()

	//* '''Write''' はバイトを想定しています。文字としての '''s''' を持っていたら、'''[]byte(s)''' でキャストします。
	h.Write([]byte(s))

	//* バイトスライスとなった、ファイナライズされたハッシュをこれで取得できます。'''Sum''' に渡す引数はバイトスライスに追加されますが、通常は必要ありません。
	bs := h.Sum(nil)

	//* SHA1 の値は、例えば git のコミットのように 16 進数でしばしば出力されます。~
	//* '''%x''' フォーマットを使うとハッシュの結果を 16 進数の文字列へ変換可能です。
	spew.Printf("%#+v\n", s)
	spew.Printf("%x\n", bs)
}

func main() {
	// p = fmt.Println

	//* RFC3339 に一致する定数を使って、RFC3339 に従った時刻フォーマットの例です。
	t := time.Now()
	spew.Printf("%#+v\n", t.Format(time.RFC3339))

	//* 時刻のパースは、同じレイアウト値を '''Format''' として使います。
	t1, _ := time.Parse(time.RFC3339, "2012-11-01T22:08:41+00:00")
	spew.Printf("%#+v\n", t1)

	//* '''Format''' と '''Parse''' は例を基にしたレイアウトを使います。大抵は '''time''' からの定数をこれらのレイアウトのために使うことになりますが、カスタムレイアウトを使うことも可能です。
	//* レイアウトは '''Mon Jan 2 15:04:05 MST 2006''' の参照を使います。これは指定の 時刻 / 文字列をフォーマット / パースするためのパターンを示すためにです。~
	//* 例となる時刻は以下の様になっていなければいけません: 2006（年）、 15（時間）、Monday（曜日）etc.
	spew.Printf("%#+v\n", t.Format("3:04PM"))                   // t を Format() に指定した例でフォーマット。
	spew.Printf("%#+v\n", t.Format("Mon Jan _2 15:04:05 2006")) // 日にちのアンダースコアは何なのだろう？
	spew.Printf("%#+v\n", t.Format("2006-01-02T15:04:05.999999-07:00"))
	/*
	 * よくわからん。
	 * time.Parse() の第一引数はレイアウトで、第二引数が時刻っぽいが、
	 * form をいじっても望み通りのフォーマットにならない。
	 */
	form := "3 04 PM"
	t2, _ := time.Parse(form, "8 41 PM")
	spew.Printf("%#+v\n", t2)

	//* 純粋な数値表示のために、時刻値の抽出されたコンポーネントを使って標準文字フォーマットを利用することができます。
	fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())

	//* '''Parse''' は不正な入力時にパース処理の問題点を報告するエラーを返します。
	ansic := "Mon Jan _2 15:04:05 2006"
	_, err := time.Parse(ansic, "8:41PM")
	spew.Printf("%#+v\n", err)
}

func main() {
	//* これはエンコード / デコードする '''string''' です。
	data := "abc123!?$*&()'[email protected]~'"

	//* Go は標準および URL 互換な base64 をサポートしています。これは、標準のエンコーダを使った方法です。エンコーダは '''[]byte''' を必要とするので、'''string''' をキャストします。
	sEnc := b64.StdEncoding.EncodeToString([]byte(data))
	spew.Printf("%#+v\n", sEnc)

	//* デコード時はエラーを返す場合があります。エラーを使って、適切に形成された入力値かどうかチェックすることができます。
	sDec, _ := b64.StdEncoding.DecodeString(sEnc)
	spew.Printf("%#+v\n", string(sDec))

	//* これは URL 互換な base64 フォーマットを使ったエンコード / デコードです。
	uEnc := b64.URLEncoding.EncodeToString([]byte(data))
	spew.Printf("%#+v\n", uEnc)
	uDec, _ := b64.URLEncoding.DecodeString(uEnc)
	spew.Printf("%#+v\n", string(uDec))
}

func main() {
	s := new(scanner.Scanner)
	s.Init(os.Stdin)
	for {
		spew.Printf("> ")
		x := s.Scan()
		spew.Println(x, s.TokenText())
	}
}