Go: Goの関数：複数の戻り値、名前付き戻り値、可変引数、クロージャ、高階関数

// Java: Can only return one value, so it must be packaged
public class ParseResult {
    public User user;
    public int errorCode;
    public long durationMs;
    public List<String> warnings;
}

public ParseResult parseUserData(String raw) {
    // All 5 return values are listed here
    return new ParseResult(...);
}

// user_parser.go
package main

import (
    "fmt"
    "strconv"
    "strings"
    "time"
)

// Multiple return values: user + errorCode + durationMs + warnings
func parseUserData(raw string) (User, int, time.Duration, []string) {
    start := time.Now()
    var warnings []string

    parts := strings.Split(raw, ",")
    if len(parts) != 3 {
        return User{}, 400, time.Since(start), []string{"Format error: 3 fields required"}
    }

    age, err := strconv.Atoi(parts[1])
    if err != nil {
        return User{}, 400, time.Since(start), []string{"Invalid age format"}
    }

    if age < 0 || age > 150 {
        warnings = append(warnings, "Age Anomaly")
    }

    user := User{Name: parts[0], Age: age, City: parts[2]}
    return user, 200, time.Since(start), warnings
}

type User struct {
    Name string
    Age  int
    City string
}

func main() {
    user, code, duration, warnings := parseUserData("Alice,28,Shanghai")

    fmt.Printf("Status: %d\n", code)
    fmt.Printf("User: %+v\n", user)
    fmt.Printf("Duration: %v\n", duration)
    fmt.Printf("Warnings: %v\n", warnings)
}

Status: 200
User: {Name:Alice Age:28 City:Shanghai}
Duration: 12.5µs
Warnings: []

func functionName(param1 type1, param2 type2) returnType {
    // Function Body
    return value
}

package main

import "fmt"

// Form 1: No parameters, no return value
func sayHello() {
    fmt.Println("Hello!")
}

// Form 2: With parameters but no return value
func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

// Form 3: With parameters and a return value
func add(a, b int) int {
    return a + b
}

// Form 4: Multiple Parameters and Multiple Return Values
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    sayHello()                              // Hello!
    greet("Alice")                          // Hello, Alice!
    fmt.Println(add(2, 3))                  // 5
    result, err := divide(10.0, 2.0)
    fmt.Printf("%.2f, err=%v\n", result, err)  // 5.00, err=<nil>
}

Hello!
Hello, Alice!
5
5.00, err=<nil>

func add(a, b int) int  // equivalent to a int, b int
func rect(w, h int) (int, int)  // both parameters are int

package main

import "fmt"

func swap(a, b string) (string, string) {
    return b, a
}

func main() {
    x, y := swap("hello", "world")
    fmt.Println(x, y)  // world hello
}

package main

import (
    "errors"
    "fmt"
)

func findUser(id int) (string, error) {
    if id <= 0 {
        return "", errors.New("invalid id")
    }
    if id == 999 {
        return "", fmt.Errorf("user %d not found", id)
    }
    return fmt.Sprintf("User-%d", id), nil
}

func main() {
    user, err := findUser(1)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Found: %s\n", user)

    // To ignore a return value: use _
    _, err = findUser(999)
    fmt.Printf("Ignored: err=%v\n", err)
}

Found: User-1
Ignored: err=user 999 not found

package main

import "fmt"

func calc(a, b int) (sum, diff, product int) {
    sum = a + b
    diff = a - b
    product = a * b
    return  // bare return, automatically returns sum/diff/product
}

func main() {
    s, d, p := calc(10, 3)
    fmt.Printf("sum=%d, diff=%d, product=%d\n", s, d, p)
}

sum=13, diff=7, product=30

package main

import "fmt"

func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

func main() {
    fmt.Println(sum(1, 2, 3))        // 6
    fmt.Println(sum(10, 20))         // 30
    fmt.Println(sum())               // 0

    // Break the slice apart and pass it in: nums...
    nums := []int{1, 2, 3, 4, 5}
    fmt.Println(sum(nums...))        // 15
}

6
30
0
15

package main

import "fmt"

// Similar to `fmt.Printf`: The first argument is fixed, and the rest are variable.
func logMessage(level string, args ...interface{}) {
    fmt.Printf("[%s] ", level)
    fmt.Println(args...)  // spread slice and pass to Println
}

func main() {
    logMessage("INFO", "Server started", "on port", 8080)
    logMessage("ERROR", "Database connection failed:", "timeout 5s")
    logMessage("DEBUG")
}

[INFO] Server started on port 8080
[ERROR] Database connection failed: timeout 5s
[DEBUG]

package main

import "fmt"

func main() {
    // Assign to a variable
    add := func(a, b int) int {
        return a + b
    }
    fmt.Println(add(2, 3))  // 5

    // Direct Call
    func(x int) {
        fmt.Printf("Anonymous function: x=%d\n", x)
    }(42)
}

5
Anonymous function: x=42

package main

import "fmt"

// Returns a closure: increments by 1 on each call
func makeCounter() func() int {
    count := 0  // variable captured by closure
    return func() int {
        count++
        return count
    }
}

func main() {
    counter := makeCounter()
    fmt.Println(counter())  // 1
    fmt.Println(counter())  // 2
    fmt.Println(counter())  // 3

    // Each counter is an independent closure.
    another := makeCounter()
    fmt.Println(another())  // 1 (restarts counting)
}

1
2
3
1

// registry.go
package main

import "fmt"

var registry = make(map[string]int)

func init() {
    registry["version"] = 1
    registry["max_connections"] = 100
    fmt.Println("[init] registry initialized")
}

func init() {
    registry["debug"] = 1
    fmt.Println("[init] debug enabled")
}

func main() {
    fmt.Printf("Registry: %+v\n", registry)
}

[init] registry initialized
[init] debug enabled
Registry: map[debug:1 max_connections:100 version:1]

package main

import "fmt"

// The second parameter is the function type: it accepts an `int` and returns an `int`.
func process(nums []int, callback func(int) int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = callback(n)
    }
    return result
}

func double(n int) int { return n * 2 }
func square(n int) int { return n * n }

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

    doubled := process(nums, double)
    fmt.Println("doubled:", doubled)

    squared := process(nums, square)
    fmt.Println("squared:", squared)
}

doubled: [2 4 6 8 10]
squared: [1 4 9 16 25]

package main

import "fmt"

func makeAdder(x int) func(int) int {
    return func(y int) int {
        return x + y
    }
}

func main() {
    add10 := makeAdder(10)
    add100 := makeAdder(100)

    fmt.Println(add10(5))     // 15
    fmt.Println(add100(5))    // 105
}

15
105

package main

import "fmt"

func mapFunc(nums []int, f func(int) int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = f(n)
    }
    return result
}

func filterFunc(nums []int, predicate func(int) bool) []int {
    var result []int
    for _, n := range nums {
        if predicate(n) {
            result = append(result, n)
        }
    }
    return result
}

func reduceFunc(nums []int, initial int, f func(int, int) int) int {
    acc := initial
    for _, n := range nums {
        acc = f(acc, n)
    }
    return acc
}

func main() {
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    // 1. Map: Each element *2
    doubled := mapFunc(nums, func(n int) int { return n * 2 })

    // 2. Filter: Keep even numbers
    evens := filterFunc(nums, func(n int) bool { return n%2 == 0 })

    // 3. Reduce: Sum
    sum := reduceFunc(nums, 0, func(acc, n int) int { return acc + n })

    fmt.Printf("doubled: %v\n", doubled)
    fmt.Printf("evens: %v\n", evens)
    fmt.Printf("sum: %d\n", sum)
}

doubled: [2 4 6 8 10 12 14 16 18 20]
evens: [2 4 6 8 10]
sum: 55

// pipeline.go
package main

import (
    "fmt"
    "strings"
    "time"
)

// Data Sources
func extract() []string {
    return []string{
        "  Alice,28,Shanghai  ",
        "Bob,32,Beijing",
        "CHARLIE,45,Guangzhou",
        "",  // empty data
        "Dave,abc,ErrorCity",  // anomalous data
    }
}

// Step 1: Remove Spaces + Split Fields
func trim(s string) []string {
    return strings.Split(strings.TrimSpace(s), ",")
}

// Step 2: Convert to uppercase
func upper(s []string) []string {
    for i, v := range s {
        s[i] = strings.ToUpper(v)
    }
    return s
}

// Step 3: Verify the number of fields
func validate(s []string) (string, bool) {
    if len(s) != 3 || s[0] == "" {
        return "", false
    }
    return strings.Join(s, "|"), true
}

// Pipeline Function: Combining 3 Steps + Defer Report
func processPipeline(name string, data []string) (valid int, errors int) {
    defer func() {
        // Name the return value so that `defer` can modify the result
        fmt.Printf("[%s] Completed: valid=%d errors=%d duration=%v\n",
            name, valid, errors, time.Since(startTime))
    }()

    for _, raw := range data {
        s := trim(raw)
        if len(s) < 3 {
            errors++
            continue
        }
        s = upper(s)
        if result, ok := validate(s); ok {
            valid++
            fmt.Printf("  -> %s\n", result)
        } else {
            errors++
        }
    }
    return valid, errors
}

var startTime = time.Now()

func main() {
    fmt.Println("=== Start of Data Pipeline ===")

    // Combining Steps Using Functions as Arguments
    data := extract()
    valid, errors := processPipeline("ETL-1", data)

    fmt.Printf("\nSummary: valid=%d, errors=%d\n", valid, errors)
}

=== Start of Data Pipeline ===
  -> ALICE|28|SHANGHAI
  -> BOB|32|BEIJING
  -> CHARLIE|45|GUANGZHOU
  -> DAVE|ABC|ERRORCITY
[ETL-1] Completed: valid=4 errors=1 duration=2.5µs

Summary: valid=4, errors=1