func div(numerator int, denominator int) int {
    if denominator == 0 {
        return 0
    }
    return numerator / denominator
}

type MyFuncOpts sturct {
    FirstName string
    LastName string
    Age int
}

func MyFunc(opts MyFuncOpts) error {
    // do something
}

func main() {
    MyFunc(MyFuncOpts {
        LastName: "Patel",
        Age: 50,
    })
    MyFunc(MyFuncOpts {
        FirstName: "Joe",
        LastName: "Smith",
    })
}

func addTo(base int, vales ...int) []int {
    out := make([]int, 0., len(vals))
    for _, v := range vals {
        out = append(out, base+v)
    }
    return out
}

// 아래와 같이 여러 가지 방법으로 호출할 수 있다.
// addTo(3)
// addTo(3, 2)
// addTo(3, 2, 4 ,6)
// addTo(3, []int{1, 2, 3, 4, 5})

func divAndRemainder(numerator int, denominator int) (int, int, error) {
    if denominator == 0 {
        return 0, 0, erros.New("Cannot divide by zero")
    }
    return numerator / denominator, numerator % denominator, nil
}

// result, remainder, err := divAndRemainder(10 , 2)

type opFuncType func(int,int) int

func main(){
    for i := 0; i< 5; i++ {
        func(j int) {
            fmt.Println("printing", j, "from inside of anonymous function")
        }(i)
    }
}

type Person struct {
    FirstName string
    LastName  string
    Age       int
}

people := []Person{
    {"Pat", "Patterson", 37},
    {"Tracy", "Bobbert", 23},
    {"Fred", "Fredson", 18},
}

// 성으로 정렬
sort.Slice(people, func(i int, j int) bool {
    return people[i].LastName < poeple[j].LastName
})

// 나이로 정렬
sort.Slice(people, func(i int, j int) bool {
    return people[i].Age < poeple[j].Age
})

func makeMult(base int) func(int) int {
    return func(factor int) int {
        return base * factor
    }
}

func main() {
    twoBase := makeMult(2)
    threeBase := makeMult(3)
    for i := 0; i < 3; i++ {
        fmt.Println(towBase(i), threeBase(i))
    }
}

func main() {
    if len(os.Args) < 2 {
        log.Fatal("no file specified")
    }
    f, err := os.Open(os.Args[1])
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    // 유효한 파일 핸들을 얻고나서, 파일을 사용하고 함수가 어떤 식으로 종료되었던 간에 닫아줘야 한다.

    _data := make([]byte, 2048)
    for {
        count, err := f.Read(data)
        os.Stdout.Write(data[:count])
        if err != nil {
            if err != io.EOF {
                log.Fatal(err)
            }
            break
        }
    }
}

func getFile(name string) (*os.File, func(), error) {
    file, err := os.Open(name)
    if err != nil {
        return nil, nil, err
    }
    return file, func() {
        file.Close()
    }, err
}
// 위 헬퍼 함수는 파일, 함수 그리고 오류를 반환한다.

func main() {
    f, closer, err := getFile(os.Args[1])
    if err != nil {
        log.Fatal(err)
    }
    defer closer()
}