Functions and Methods

The Refactoring That Changed My Mind

Week two with Go, I was refactoring our authentication service. In Python, I'd written:

def authenticate_user(email, password):
    try:
        user = database.get_user(email)
        if check_password(user, password):
            return create_token(user)
        else:
            return None
    except UserNotFound:
        return None
    except DatabaseError as e:
        log_error(e)
        return None

Every error path returned None. The caller had to guess why authentication failed. Was it bad credentials? Database error? User not found?

In Go, I rewrote it:

func authenticateUser(email, password string) (string, error) {
    user, err := database.GetUser(email)
    if err != nil {
        return "", fmt.Errorf("failed to get user: %w", err)
    }
    
    if !checkPassword(user, password) {
        return "", errors.New("invalid credentials")
    }
    
    token, err := createToken(user)
    if err != nil {
        return "", fmt.Errorf("failed to create token: %w", err)
    }
    
    return token, nil
}

Two return values changed everything. The caller gets both the result AND the error. No guessing. No exceptions. No hidden control flow.

This article covers how Go's approach to functions eliminates entire classes of bugs.

---

Function Declaration

Basic Function

func greet(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

greet("Alice")  // Hello, Alice!

Syntax: func keyword, name, parameters in parentheses, body in braces.

Function with Return Value

func add(a, b int) int {
    return a + b
}

result := add(5, 3)  // 8

Return type comes after parameters.

Multiple Parameters of Same Type

// Verbose
func add(a int, b int, c int) int {
    return a + b + c
}

// Idiomatic (share type declaration)
func add(a, b, c int) int {
    return a + b + c
}

---

Multiple Return Values

This is Go's killer feature for error handling.

Returning Multiple Values

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println("Result:", result)  // Result: 5

Pattern: Return (result, error) - result first, error last.

Real-World Example: File Reading

func readConfig(filename string) (Config, error) {
    data, err := os.ReadFile(filename)
    if err != nil {
        return Config{}, fmt.Errorf("read file: %w", err)
    }
    
    var config Config
    err = json.Unmarshal(data, &config)
    if err != nil {
        return Config{}, fmt.Errorf("parse JSON: %w", err)
    }
    
    return config, nil
}

Every step can fail. Every error is handled explicitly.

Ignoring Return Values

// Ignore error (not recommended!)
result, _ := divide(10, 2)

// Ignore result
_, err := divide(10, 0)
if err != nil {
    // Handle error
}

Use _ to explicitly ignore values. The compiler won't complain.

---

Named Return Values

Named returns create variables automatically:

func divide(a, b float64) (result float64, err error) {
    if b == 0 {
        err = errors.New("division by zero")
        return  // Returns result=0, err=error
    }
    result = a / b
    return  // Returns result, err=nil
}

Benefits:

• Documents what's being returned

• Variables auto-initialized to zero values

• Naked return returns named values

When I use them: Complex functions where return values need documentation.

Named Returns for Clarity

func parseUser(data []byte) (user User, warnings []string, err error) {
    // Implementation
    return  // Clear what's being returned
}

vs

func parseUser(data []byte) (User, []string, error) {
    // What's the second value?
    return user, warnings, nil
}

---

Variadic Functions

Functions that accept variable number of arguments:

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

fmt.Println(sum(1, 2, 3))        // 6
fmt.Println(sum(1, 2, 3, 4, 5))  // 15
fmt.Println(sum())               // 0

The ... creates a slice of the type.

Passing Slice to Variadic Function

numbers := []int{1, 2, 3, 4, 5}
total := sum(numbers...)  // Spread operator

Real Example: Logging Function

func log(level string, format string, args ...interface{}) {
    timestamp := time.Now().Format("2006-01-02 15:04:05")
    message := fmt.Sprintf(format, args...)
    fmt.Printf("[%s] %s: %s\n", timestamp, level, message)
}

log("INFO", "User %s logged in from %s", "alice", "192.168.1.1")
log("ERROR", "Failed to connect to database")

This is how fmt.Printf works internally!

---

Functions as Values

Functions are first-class citizens in Go.

Assign Function to Variable

func add(a, b int) int {
    return a + b
}

// Assign to variable
var operation func(int, int) int
operation = add

result := operation(5, 3)  // 8

Anonymous Functions

// Function literal (anonymous function)
multiply := func(a, b int) int {
    return a * b
}

result := multiply(4, 5)  // 20

Immediately Invoked Function

result := func(a, b int) int {
    return a + b
}(5, 3)  // 8

Real Example: Middleware Pattern

From my HTTP server:

type HandlerFunc func(http.ResponseWriter, *http.Request)

func loggingMiddleware(next HandlerFunc) HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        defer func() {
            fmt.Printf("%s %s - %v\n", r.Method, r.URL.Path, time.Since(start))
        }()
        next(w, r)
    }
}

// Usage
http.HandleFunc("/api/users", loggingMiddleware(handleUsers))

---

Closures

Functions can capture variables from surrounding scope:

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

c := counter()
fmt.Println(c())  // 1
fmt.Println(c())  // 2
fmt.Println(c())  // 3

// Each counter is independent
c2 := counter()
fmt.Println(c2())  // 1

Real Example: Rate Limiter

func rateLimiter(maxCalls int, duration time.Duration) func() bool {
    var calls int
    var lastReset time.Time
    
    return func() bool {
        now := time.Now()
        
        // Reset if duration passed
        if now.Sub(lastReset) > duration {
            calls = 0
            lastReset = now
        }
        
        // Check limit
        if calls >= maxCalls {
            return false  // Rate limited
        }
        
        calls++
        return true  // Allowed
    }
}

// Allow 10 calls per minute
limiter := rateLimiter(10, time.Minute)

for i := 0; i < 15; i++ {
    if limiter() {
        fmt.Printf("Request %d: OK\n", i+1)
    } else {
        fmt.Printf("Request %d: RATE LIMITED\n", i+1)
    }
}

---

Methods on Types

Go doesn't have classes, but you can define methods on types.

Method Declaration

type User struct {
    Name  string
    Email string
}

// Method with value receiver
func (u User) Greet() string {
    return fmt.Sprintf("Hello, I'm %s", u.Name)
}

user := User{Name: "Alice", Email: "[email protected]"}
fmt.Println(user.Greet())  // Hello, I'm Alice

The (u User) is the receiver.

Value Receivers vs Pointer Receivers

This tripped me up initially:

type Counter struct {
    count int
}

// Value receiver - receives a copy
func (c Counter) IncrementWrong() {
    c.count++  // Modifies copy, not original!
}

// Pointer receiver - modifies original
func (c *Counter) Increment() {
    c.count++  // Modifies original
}

counter := Counter{}
counter.IncrementWrong()
fmt.Println(counter.count)  // 0 (unchanged!)

counter.Increment()
fmt.Println(counter.count)  // 1

Rule of thumb:

• Use pointer receivers when modifying the receiver

• Use pointer receivers for large structs (avoid copying)

• Use value receivers for small, immutable types

Real Example: HTTP Client

type APIClient struct {
    baseURL string
    token   string
    client  *http.Client
}

func NewAPIClient(baseURL, token string) *APIClient {
    return &APIClient{
        baseURL: baseURL,
        token:   token,
        client:  &http.Client{Timeout: 30 * time.Second},
    }
}

func (c *APIClient) Get(endpoint string) ([]byte, error) {
    url := c.baseURL + endpoint
    
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", "Bearer "+c.token)
    
    resp, err := c.client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    return io.ReadAll(resp.Body)
}

// Usage
client := NewAPIClient("https://api.example.com", "secret-token")
data, err := client.Get("/users")

---

Methods on Non-Struct Types

You can define methods on any type you define:

type Temperature float64

func (t Temperature) Celsius() float64 {
    return float64(t)
}

func (t Temperature) Fahrenheit() float64 {
    return float64(t)*9/5 + 32
}

temp := Temperature(25)
fmt.Printf("%.1f°C = %.1f°F\n", temp.Celsius(), temp.Fahrenheit())
// 25.0°C = 77.0°F

Real Example: Custom String Type

type Email string

func (e Email) Validate() error {
    if !strings.Contains(string(e), "@") {
        return errors.New("invalid email")
    }
    return nil
}

func (e Email) Domain() string {
    parts := strings.Split(string(e), "@")
    if len(parts) != 2 {
        return ""
    }
    return parts[1]
}

email := Email("[email protected]")
if err := email.Validate(); err != nil {
    fmt.Println("Invalid email")
}
fmt.Println(email.Domain())  // example.com

---

Function Types

You can define function types:

type Operation func(int, int) int

func apply(a, b int, op Operation) int {
    return op(a, b)
}

add := func(a, b int) int { return a + b }
multiply := func(a, b int) int { return a * b }

fmt.Println(apply(5, 3, add))      // 8
fmt.Println(apply(5, 3, multiply))  // 15

Real Example: Validation Pipeline

type Validator func(string) error

func runValidators(value string, validators ...Validator) error {
    for _, validate := range validators {
        if err := validate(value); err != nil {
            return err
        }
    }
    return nil
}

notEmpty := func(s string) error {
    if s == "" {
        return errors.New("cannot be empty")
    }
    return nil
}

minLength := func(min int) Validator {
    return func(s string) error {
        if len(s) < min {
            return fmt.Errorf("must be at least %d characters", min)
        }
        return nil
    }
}

email := "alice"
err := runValidators(email, notEmpty, minLength(5))
if err != nil {
    fmt.Println("Validation failed:", err)
}

---

Defer with Functions

Defer can wrap cleanup logic:

func processFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer f.Close()
    
    // Process file
    scanner := bufio.NewScanner(f)
    for scanner.Scan() {
        processLine(scanner.Text())
    }
    
    return scanner.Err()
}

Defer for Timing

func slowOperation() {
    defer track(time.Now(), "slowOperation")
    
    // Do work
    time.Sleep(2 * time.Second)
}

func track(start time.Time, name string) {
    fmt.Printf("%s took %v\n", name, time.Since(start))
}
// slowOperation took 2.001s

---

Practical Example: Builder Pattern

Real code for building database queries:

type QueryBuilder struct {
    table  string
    where  []string
    limit  int
    offset int
}

func NewQuery(table string) *QueryBuilder {
    return &QueryBuilder{table: table}
}

func (q *QueryBuilder) Where(condition string) *QueryBuilder {
    q.where = append(q.where, condition)
    return q  // Return self for chaining
}

func (q *QueryBuilder) Limit(n int) *QueryBuilder {
    q.limit = n
    return q
}

func (q *QueryBuilder) Offset(n int) *QueryBuilder {
    q.offset = n
    return q
}

func (q *QueryBuilder) Build() string {
    query := "SELECT * FROM " + q.table
    
    if len(q.where) > 0 {
        query += " WHERE " + strings.Join(q.where, " AND ")
    }
    
    if q.limit > 0 {
        query += fmt.Sprintf(" LIMIT %d", q.limit)
    }
    
    if q.offset > 0 {
        query += fmt.Sprintf(" OFFSET %d", q.offset)
    }
    
    return query
}

// Usage - method chaining!
query := NewQuery("users").
    Where("age > 18").
    Where("active = true").
    Limit(10).
    Offset(20).
    Build()

fmt.Println(query)
// SELECT * FROM users WHERE age > 18 AND active = true LIMIT 10 OFFSET 20

---

Common Patterns

Options Pattern

type Server struct {
    host    string
    port    int
    timeout time.Duration
}

type Option func(*Server)

func WithPort(port int) Option {
    return func(s *Server) {
        s.port = port
    }
}

func WithTimeout(timeout time.Duration) Option {
    return func(s *Server) {
        s.timeout = timeout
    }
}

func NewServer(host string, opts ...Option) *Server {
    s := &Server{
        host:    host,
        port:    8080,  // Default
        timeout: 30 * time.Second,  // Default
    }
    
    for _, opt := range opts {
        opt(s)
    }
    
    return s
}

// Usage
server := NewServer("localhost", WithPort(3000), WithTimeout(60*time.Second))

---

Your Challenge

Build a simple calculator with these features:

type Calculator struct {
    // Your fields
}

// Implement these methods:
// func (c *Calculator) Add(n float64) *Calculator
// func (c *Calculator) Subtract(n float64) *Calculator
// func (c *Calculator) Multiply(n float64) *Calculator
// func (c *Calculator) Divide(n float64) error
// func (c *Calculator) Result() float64
// func (c *Calculator) Reset()

// Should support chaining:
calc := &Calculator{}
result := calc.Add(10).Multiply(2).Subtract(5).Result()
// result should be 15

---

Key Takeaways

1. Multiple returns: Return both result and error explicitly

2. Named returns: Document what's being returned

3. Variadic functions: Accept variable arguments with ...

4. Functions as values: Pass functions around like data

5. Closures: Functions capture surrounding variables

6. Pointer receivers: Modify the receiver or avoid copying

7. Value receivers: For small, immutable types

8. Method chaining: Return *self for fluent APIs

---

What I Learned

The authentication refactoring taught me that Go's approach to functions isn't restrictive - it's liberating:

• Multiple returns eliminated exception handling confusion

• Explicit errors made error paths visible

• Methods on types organized code without classes

• Closures enabled powerful patterns (middleware, options)

Coming from Python's single return value and exceptions, this felt verbose. But in production, explicit error handling caught bugs at compile time that would have been runtime crashes.

---

Next: Data Structures - Arrays, Slices, Maps

In the next article, we'll explore Go's built-in data structures. You'll learn about slices (Go's most-used data structure), maps, and the memory leak that taught me how they really work.