var x int = 10

var x = 10

var x, y int = 10,  20

var x, y = 10, "hello"

var (
    x int
    y = 20
    z, a = 40, "hello"
)

x := 30

const x = 10

// 許容される
var y int = x
var z float64 = x
var d byte = x

const typedX int = 10
// コンパイルエラー
var z float64 = typedX

var x = [...]int {10, 20, 30}

var x = []int {10, 20 ,30}
// 5のインデックスに4、10のインデックスに100が入る
// [1 0 0 0 0 4 6 15 0 0 100]
var y = []int{1, 5:4, 6, 15, 10:100}

x := []int{1,2,3}
y := []int{1,2,3}
z := []int{1,2,3,4}
s := []string{"a", "b", "c"}
// true
fmt.Println(slices.Equal(x, y))
// false
fmt.Println(slices.Equal(x, z))
// コンパイルエラー
fmt.Println(slices.Equal(x, s))

var x []int
x = append(x, 10)

// 展開して追加
y := []int{1,2,3}
x = append(x, y...)

x := make([]int, 5)

s := []string{"one", "second", "third"}
clear(s)

x := []int{1,2,3}
y := make([]int, 4)
num := copy(y, x)

var nilMap map[string]int

totalWins := map[string]int{}
// mapの追加
totalWins["abc"] = 3
// mapの削除
delete(totalWins, "abc")

m := map[string]int {
    "hello" : 5,
    "world" : 0,
}
v, ok := m["hello"]
// 5, true
fmt.Println(v, ok)
v, ok := m["abc"]
// 0, false
fmt.Println(v, ok)

m := map[string]int {
    "hello" : 5,
    "world" : 0,
}
clear(m)

m := map[string]int {
    "hello" : 5,
    "world" : 10,
}


n := map[string]int {
    "hello" : 5,
    "world" : 10,
}

maps.Equal(m, n)

type person struct {
    name string
    age int
    pet string
}

julia := person{
    "name 1",
    50,
    "cat"
}
// フィールド名指定初期化
beth := person{
    age:30,
    name: "ベス"
}

// 変数に直接構造体を宣言
var person struct {
    name string
    age int
    pet string
}
person.name = "ボブ"
person.age = 50
person.pet = "dog"

pet := struct {
    name string
    kind string
} {
    name: "ポチ",
    kind: "dog"
}

func main() {
    x := 10
    if x > 5 {
        // 10
        fmt.Println(x)
        // シャドーイング変数
        x := 5
        // 5
        fmt.Println(x)
    }
    // 10 内側のブロックで定義された変数は破棄されているため
    fmt.Println(x)
}

import "fmt"

func main() {
    x := 10
    fmt.Println(x)
    fmt := "aaaaa"
    // コンパイルエラー
    fmt.Println(fmt)
}

type MyFuncOpts struct {
    FirstName string
    LastName string
    Age int
}

func MyFunc(opts MyFuncOpts) error {
    fmt.Println(opts)
    fmt.Println("< ここで必要な処理を行う>")
    return nul
}

func main() {
    // 省略した構造体にはゼロ値が入る
    // 構造体の要素がパラメータのように使える
    MyFunc(MyFuncOpts {
        LastName: "Patel",
        Age: 50
    })
    MyFunc(MyFuncOpts {
        FirstName: "Joe",
        LastName: "Smith",
    })

func divAndRemainder(num, denom int) (int, int, error) {
	if denom == 0 {
		return 0, 0, errors.New("0で割ることはできません")
	}
	return num / denom, num % denom, nil
}

func divAndRemainder(num, denom int) (result int, remainder int, err error) {
	if denom == 0 {
		return 0, 0, errors.New("0で割ることはできません")
	}
	result = num / denom
	remainder = num % denom
	return result, remainder, nil
}

func divAndRemainder(num, denom int) (result int, remainder int, err error) {
	if denom == 0 {
		return 0, 0, errors.New("0で割ることはできません")
	}
	result = num / denom
	remainder = num % denom
	return
}

package calc

import (
	"fmt"
	"strconv"
)

func add(i int, j int) int {
	return i + j
}

func sub(i int, j int) int {
	return i - j
}

func mul(i int, j int) int {
	return i * j
}

func div(i int, j int) int {
	return i / j
}

func Execute() {
    // mapに値として関数を持たせる
	opMap := map[string]func(int, int) int{
		"+": add,
		"-": sub,
		"*": mul,
		"/": div,
	}

	expressions := [][]string{
		{"2", "+", "3"},
		{"2", "-", "3"},
		{"2", "*", "3"},
		{"2", "/", "3"},
		{"2", "%", "3"},
		{"two", "+", "three"},
		{"2", "+", "three"},
		{"5"},
	}
	for _, exexpression := range expressions {
		if len(exexpression) != 3 {
			fmt.Print(exexpression, "不正な式です\n")
			continue
		}
		p1, err := strconv.Atoi(exexpression[0])
		if err != nil {
			fmt.Print(exexpression[0], "不正なオペランドです\n")
			continue
		}
		op := exexpression[1]
		opFunc, ok := opMap[op]
		if !ok {
			fmt.Print(op, "不正な演算子です\n")
			continue
		}
		p2, err := strconv.Atoi(exexpression[2])
		if err != nil {
			fmt.Print(exexpression[2], "不正なオペランドです\n")
			continue
		}
		result := opFunc(p1, p2)
		fmt.Printf("%d %s %d = %d\n", p1, op, p2, result)
	}
}

var x int32 = 10
var y bool = true
// ポインタ
// %!s(*int32=0xc000010050) 
// %!s(*bool=0xc000010054) 
// %!s(*string=<nil>) 
pointerX := &x
pointerY := &y
// 何のアドレスも指定されていないのでnil
var pointerZ *string

x := "hello"
pointerX := &x

x := "hello"
pointerX := &x
// アドレスが表示
fmt.Println(pointerX)
// 値が表示
fmt.Println(*pointerX)
z := *pointerX + "world"
// hello world
fmt.Println(z)

x := 10
var pointerX *int
pointerX = &x

type Person struct {
    FirstName string
    LastName string
    Age int
}

type Person struct {
    FirstName string
    LastName string
    Age int
}

// 型Personに付随するメソッドStringを定義
// このメソッドは「レシーバー」という特別な引数を持つ関数
// レシーバーpにはPerson型のインスタンスが指定されている
func (p Person) String() string {
    return fmt.Sprintf("%s %s:年齢%d歳", p.LastName, p.FirstName, p.Age)
}

type Counter struct {
	total      int
	lastUpdate time.Time
}

// 値を更新するのでポインタ
func (c *Counter) Increment() {
	c.total++
	c.lastUpdate = time.Now()
}

// 値を参照しているのでコピー
func (c Counter) String() string {
	return fmt.Sprintf("total: %d, lastUpdate: %v", c.total, c.lastUpdate)
}
// この関数を呼んでもコピーなので内部のカウントが増えない
func doUpdateWrong(c Counter) {
	c.Increment()
	fmt.Println("Inside doUpdateWrong:", c)
}
// この関数をよぶとポインタなのでカウントが増える
func doUpdateRight(c *Counter) {
	c.Increment()
	fmt.Println("Inside doUpdateRight:", c)
}

package tree

type IntTree struct {
	Left  *IntTree
	Value int
	Right *IntTree
}

func (it *IntTree) Insert(val int) *IntTree {
	if it == nil {
		return &IntTree{Value: val}
	}
	if val < it.Value {
		it.Left = it.Left.Insert(val)
	} else {
		it.Right = it.Right.Insert(val)
	}
	return it
}

func (it *IntTree) Contains(val int) bool {
	if it == nil {
		return false
	}
	if val == it.Value {
		return true
	} else if val < it.Value {
		return it.Left.Contains(val)
	} else {
		return it.Right.Contains(val)
	}
}

const (
    // 一行目はiotaが0
	UnCategorized DefineValue = iota
    // 二行目が1
	CategoryA
    // 三行目が2
	CategoryB
	CategoryC
)
const (
	const_value1 = 0
    // 二行目はiotaが1なので6の値になる
	const_value2 = iota + 5
    // 前の値からインクリメントして7の値になる
	const_value3
	const_value4
)

package employee

import "fmt"

type Employee struct {
	Name string
	ID   string
}

func (e Employee) Description() string {
	return fmt.Sprintf("Employee Name: %s, ID: %s", e.Name, e.ID)
}

type Manager struct {
	Employee
	Reports []Employee
}

func (m Manager) FindNewEmployee() []Employee {
	newEmployees := []Employee{
		{Name: "Alice", ID: "E001"},
		{Name: "Bob", ID: "E002"},
	}
	return newEmployees
}

type Stringer interface {
    String() string
}

package logic

import "fmt"

type LogicProvider struct{}

func (lp LogicProvider) Process(data string) string {
	fmt.Println("Processing data:", data)
	return "Processed"
}

type Logic interface {
	Process(data string) string
}

type Client struct {
	Logic Logic
}

func (c Client) Program() {
	c.Logic.Process("Some data")
}

package logic

import "testing"

func TestLogic(t *testing.T) {
	lp := LogicProvider{}
	client := Client{Logic: lp}
	client.Program()
}

type Reader interface {
    Read(p []byte) (n int, err error)
}
type Closer interface {
    Close() error
}
type ReaderCloser interface {
    Reader
    Closer
}