Exercises — Module 6: Methods and Interfaces¶

Work through exercises in order — they're designed to build on each other. Attempt each problem genuinely before looking at the solution. Seeing the solution first might feel like progress, but it isn't.

Instructions¶

1. Attempt first. Spend at least the estimated time on each problem before checking hints or solutions.
2. Write your work. Don't just run code mentally — actually write or type your attempt.
3. Check your answer against the acceptance criteria, not just the solution code.
4. Score yourself honestly in the Scoring Log at the bottom.
5. If you're stuck after a genuine effort, use the hints one at a time — not all at once.

Difficulty Legend¶

Exercise 1: Implementing fmt.Stringer [🟢 Easy] [1 pt]¶

Context¶

fmt.Stringer is the most commonly implemented interface in Go. Any type that has a String() string method will have that method called automatically by fmt.Println, fmt.Printf("%v", ...), and fmt.Sprintf. Implementing it makes your types first-class citizens in any code that uses fmt.

Task¶

Define a named type Temperature as a float64. Implement fmt.Stringer on it so that it prints in the format "23.5°C" (one decimal place, degree symbol, C). Call fmt.Println with at least three Temperature values to confirm the output uses your String() method.

Requirements¶

• Temperature is a named type based on float64, not a struct
• The String() method uses a value receiver (not pointer)
• fmt.Println output matches the "23.5°C" format exactly (one decimal, °C)
• The program compiles and runs without errors

Hints¶

type Stringer interface {
    String() string
}

Expected Output / Acceptance Criteria¶

0.0°C
100.0°C
-40.0°C

Solution¶

package main

import "fmt"

// Temperature represents a temperature in Celsius
type Temperature float64

// String satisfies fmt.Stringer — called automatically by fmt verbs
func (t Temperature) String() string {
    return fmt.Sprintf("%.1f°C", float64(t))
    // Cast to float64 to avoid infinite recursion:
    // if we passed t directly, fmt.Sprintf would call t.String() again
}

func main() {
    fmt.Println(Temperature(0))    // 0.0°C
    fmt.Println(Temperature(100))  // 100.0°C
    fmt.Println(Temperature(-40))  // -40.0°C

    // Also works in other fmt contexts:
    t := Temperature(23.5)
    fmt.Printf("Current temperature: %v\n", t)  // Current temperature: 23.5°C
    fmt.Printf("Current temperature: %s\n", t)  // Current temperature: 23.5°C
}

Exercise 2: Pointer Receiver and Interface Satisfaction [🟢 Easy] [1 pt]¶

Context¶

The method set of T and *T differ: T only includes value-receiver methods, while *T includes both. This affects interface satisfaction. This exercise isolates that rule so you can see it clearly.

Task¶

Define a Counter struct with a single int field n. Add two methods: - Value() int with a value receiver — returns the current count - Increment() with a pointer receiver — increments the count by 1

Define an interface Incrementer with both methods. Demonstrate: 1. That *Counter satisfies Incrementer (assign &Counter{} to an Incrementer variable) 2. That Counter (a value) does NOT satisfy Incrementer (show the compile-time error in a comment) 3. That calling Increment() through the Incrementer interface correctly modifies the original

Requirements¶

• Value() has a value receiver; Increment() has a pointer receiver
• Assignment var inc Incrementer = &Counter{} compiles
• A comment shows what var inc Incrementer = Counter{} would produce (the error message)
• After calling inc.Increment() three times, inc.Value() returns 3

Hints¶

Expected Output / Acceptance Criteria¶

after 3 increments: 3

Solution¶

package main

import "fmt"

type Counter struct{ n int }

// Value receiver: Counter satisfies this method in its method set
func (c Counter) Value() int { return c.n }

// Pointer receiver: only *Counter satisfies this method
func (c *Counter) Increment() { c.n++ }

// Incrementer requires both Value and Increment
type Incrementer interface {
    Value() int
    Increment()
}

func main() {
    // *Counter implements Incrementer — has both Value() and Increment()
    var inc Incrementer = &Counter{}

    // Counter (value) does NOT implement Incrementer:
    // var inc2 Incrementer = Counter{}
    // compile error: Counter does not implement Incrementer
    //               (Increment method has pointer receiver)

    inc.Increment()
    inc.Increment()
    inc.Increment()

    fmt.Printf("after 3 increments: %d\n", inc.Value()) // 3
}

Exercise 3: Interface Composition with io Interfaces [🟡 Medium] [2 pts]¶

Context¶

Go's io package achieves enormous flexibility through small, composable interfaces. io.Reader, io.Writer, and io.ReadWriter (their composition) are used everywhere. This exercise builds a function that accepts the most general interface it needs — demonstrating why small interfaces and composition are powerful.

Task¶

Write a function copyAndCount(dst io.Writer, src io.Reader) (int64, error) that copies all bytes from src to dst using io.Copy, and returns the number of bytes copied and any error. Then write a main that: 1. Copies from a strings.NewReader("Hello, interfaces!") to a bytes.Buffer 2. Prints the number of bytes copied and the buffer's contents

Neither strings.Reader nor bytes.Buffer appears in the function signature — only the interfaces do.

Requirements¶

• Function signature is exactly func copyAndCount(dst io.Writer, src io.Reader) (int64, error)
• Uses io.Copy internally (do not write your own byte loop)
• main calls the function and prints both the byte count and the copied content
• Imports: "bytes", "fmt", "io", "strings"

Hints¶

Expected Output / Acceptance Criteria¶

copied 18 bytes
content: Hello, interfaces!

Solution¶

package main

import (
    "bytes"
    "fmt"
    "io"
    "strings"
)

// copyAndCount accepts the minimal interfaces it needs — not *os.File or bytes.Buffer
func copyAndCount(dst io.Writer, src io.Reader) (int64, error) {
    return io.Copy(dst, src)
}

func main() {
    src := strings.NewReader("Hello, interfaces!")  // *strings.Reader implements io.Reader
    var dst bytes.Buffer                             // bytes.Buffer implements io.Writer

    n, err := copyAndCount(&dst, src)
    if err != nil {
        fmt.Println("error:", err)
        return
    }

    fmt.Printf("copied %d bytes\n", n)
    fmt.Printf("content: %s\n", dst.String())
}

Exercise 4: Type Switch on Interface Values [🟡 Medium] [2 pts]¶

Context¶

A type switch lets you dispatch on the concrete type inside an interface value. This is essential for functions that accept any (or a broad interface) and need to behave differently based on the actual type. This exercise practices the full type switch syntax including an interface type case.

Task¶

Write a function formatValue(v any) string that returns a formatted string based on the concrete type of v: - nil → "<nil>" - int → "int: <value>" - float64 → "float64: <value>" (use %g format) - string → "string: <value>" (use %q format) - bool → "bool: <value>" - fmt.Stringer → "Stringer: <value.String()>" (any type that implements Stringer) - anything else → "other: <Go type name>"

Call formatValue with at least 7 different values (one per case, including a type that satisfies fmt.Stringer) and print the results.

Requirements¶

• Uses a type switch switch t := v.(type) { ... }
• The fmt.Stringer case is an interface type case (not a concrete type)
• All 7 case types are covered
• A custom type implementing fmt.Stringer is used to exercise that case

Hints¶

Expected Output / Acceptance Criteria¶

<nil>
int: 42
float64: 3.14
string: "hello"
bool: true
Stringer: 100.0°C
other: []int

Solution¶

package main

import "fmt"

// Reuse Temperature from Exercise 1
type Temperature float64

func (t Temperature) String() string {
    return fmt.Sprintf("%.1f°C", float64(t))
}

func formatValue(v any) string {
    switch t := v.(type) {
    case nil:
        return "<nil>"
    case int:
        return fmt.Sprintf("int: %d", t)       // t is typed int here
    case float64:
        return fmt.Sprintf("float64: %g", t)   // t is typed float64 here
    case string:
        return fmt.Sprintf("string: %q", t)    // t is typed string here
    case bool:
        return fmt.Sprintf("bool: %v", t)
    case fmt.Stringer:
        return fmt.Sprintf("Stringer: %s", t.String()) // t is typed fmt.Stringer here
    default:
        return fmt.Sprintf("other: %T", t)     // %T prints the Go type name
    }
}

func main() {
    values := []any{
        nil,
        42,
        3.14,
        "hello",
        true,
        Temperature(100),
        []int{1, 2, 3},
    }
    for _, v := range values {
        fmt.Println(formatValue(v))
    }
}

Exercise 5: Sorting a Custom Type with sort.Interface [🟡 Medium] [2 pts]¶

Context¶

sort.Interface is the canonical example of a three-method interface that makes any collection sortable. Before sort.Slice existed (Go 1.8), this was the only way to sort custom types. Understanding it deeply illustrates how interface-based extensibility works: the sort package knows nothing about your type, yet it can sort it.

Task¶

Define a Product struct with fields Name string and Price float64. Create a named type ByPrice as []Product. Implement sort.Interface on ByPrice (Len, Less, Swap). In main, create a slice of at least 5 products, sort it by price ascending, and print the results. Then sort the same slice by price descending using sort.Reverse and print again.

Requirements¶

• ByPrice implements all three methods: Len, Less, Swap
• Products are sorted ascending by price first, descending second
• sort.Reverse(ByPrice(products)) is used for the descending sort — do not re-implement Less
• Output clearly labels which sort is which

Hints¶

Expected Output / Acceptance Criteria¶

--- Ascending by price ---
Pen       $1.99
Notebook  $4.99
Stapler   $8.50
Backpack  $29.99
Laptop    $999.00

--- Descending by price ---
Laptop    $999.00
Backpack  $29.99
Stapler   $8.50
Notebook  $4.99
Pen       $1.99

Solution¶

package main

import (
    "fmt"
    "sort"
)

type Product struct {
    Name  string
    Price float64
}

// ByPrice implements sort.Interface for []Product sorted by Price
type ByPrice []Product

func (p ByPrice) Len() int           { return len(p) }
func (p ByPrice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
func (p ByPrice) Less(i, j int) bool { return p[i].Price < p[j].Price }

func main() {
    products := []Product{
        {"Laptop", 999.00},
        {"Pen", 1.99},
        {"Backpack", 29.99},
        {"Notebook", 4.99},
        {"Stapler", 8.50},
    }

    sort.Sort(ByPrice(products))
    fmt.Println("--- Ascending by price ---")
    for _, p := range products {
        fmt.Printf("%-10s $%.2f\n", p.Name, p.Price)
    }

    sort.Sort(sort.Reverse(ByPrice(products)))
    fmt.Println("\n--- Descending by price ---")
    for _, p := range products {
        fmt.Printf("%-10s $%.2f\n", p.Name, p.Price)
    }
}

Exercise 6: Designing a Domain Interface [🔴 Hard] [3 pts]¶

Context¶

Good Go interface design means defining the interface at the consumer, keeping it small, and letting multiple unrelated types satisfy it implicitly. This exercise gives you practice designing an interface from scratch and satisfying it with two independent types.

Task¶

Design a small notification system:

1. Define an interface Notifier with a single method Notify(message string) error
2. Implement EmailNotifier (a struct with ToAddress string) whose Notify method prints "[EMAIL to <addr>]: <message>" and returns nil
3. Implement SlackNotifier (a struct with Channel string) whose Notify method prints "[SLACK #<channel>]: <message>" and returns nil
4. Write a function notifyAll(notifiers []Notifier, message string) []error that calls Notify on each notifier, collects non-nil errors into a slice, and returns it
5. In main, create a mixed slice of EmailNotifier and SlackNotifier, call notifyAll, and print any errors (there should be none)

Requirements¶

• Notifier interface defined in the same file/package as the function that uses it (consumer-side)
• Both types satisfy Notifier implicitly — no implements keyword
• notifyAll accepts []Notifier, not []EmailNotifier or []SlackNotifier
• notifyAll collects errors and returns them — does not abort on first error
• The output shows both email and Slack notifications interleaved

Hints¶

notifiers := []Notifier{
    EmailNotifier{ToAddress: "alice@example.com"},
    EmailNotifier{ToAddress: "bob@example.com"},
    SlackNotifier{Channel: "alerts"},
}
errs := notifyAll(notifiers, "system maintenance at midnight")

Expected Output / Acceptance Criteria¶

[EMAIL to alice@example.com]: system maintenance at midnight
[EMAIL to bob@example.com]: system maintenance at midnight
[SLACK #alerts]: system maintenance at midnight
errors: 0

Solution¶

package main

import "fmt"

// Notifier is defined at the consumer — the notification service.
// EmailNotifier and SlackNotifier don't need to know about this interface.
type Notifier interface {
    Notify(message string) error
}

// EmailNotifier sends notifications via email (simulated here as a print)
type EmailNotifier struct {
    ToAddress string
}

func (e EmailNotifier) Notify(message string) error {
    fmt.Printf("[EMAIL to %s]: %s\n", e.ToAddress, message)
    return nil
}

// SlackNotifier sends notifications to a Slack channel (simulated)
type SlackNotifier struct {
    Channel string
}

func (s SlackNotifier) Notify(message string) error {
    fmt.Printf("[SLACK #%s]: %s\n", s.Channel, message)
    return nil
}

// notifyAll sends message to all notifiers, collecting errors
func notifyAll(notifiers []Notifier, message string) []error {
    var errs []error
    for _, n := range notifiers {
        if err := n.Notify(message); err != nil {
            errs = append(errs, err)
        }
    }
    return errs
}

func main() {
    notifiers := []Notifier{
        EmailNotifier{ToAddress: "alice@example.com"},
        EmailNotifier{ToAddress: "bob@example.com"},
        SlackNotifier{Channel: "alerts"},
    }

    errs := notifyAll(notifiers, "system maintenance at midnight")
    fmt.Printf("errors: %d\n", len(errs))
}

Exercise 7: The Typed-Nil Bug Hunt [🔴 Hard] [3 pts]¶

Context¶

The typed-nil interface bug is subtle and common. This exercise presents buggy code and asks you to find and fix it, explain why it happens at the interface value level, and write a test that would catch it.

Task¶

The following function is broken. Find the bug, fix it, explain why the original was wrong at the (type, value) pair level, and write a test (using if err != nil) that demonstrates the fix works:

type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return fmt.Sprintf("error %d: %s", e.Code, e.Message)
}

// validate returns an error if n is negative; nil otherwise.
func validate(n int) error {
    var err *AppError
    if n < 0 {
        err = &AppError{Code: 400, Message: "negative value not allowed"}
    }
    return err  // BUG IS HERE
}

Requirements¶

• Correctly identify the line with the bug and explain why it is a bug
• Provide a corrected version of validate
• Explain the (type, value) pair state of the return value when n >= 0 in the buggy version
• Write a main that calls validate(5) and validate(-1) and shows that the fixed version returns nil for n=5 and non-nil for n=-1

Hints¶

func validate(n int) error {
    if n < 0 {
        return &AppError{Code: 400, Message: "negative value not allowed"}
    }
    return nil  // untyped nil — interface has no type
}

Expected Output / Acceptance Criteria¶

validate(5):  err == nil? true   (correct)
validate(-1): err == nil? false  (correct, error: error 400: negative value not allowed)

Solution¶

package main

import "fmt"

type AppError struct {
    Code    int
    Message string
}

func (e *AppError) Error() string {
    return fmt.Sprintf("error %d: %s", e.Code, e.Message)
}

// BUGGY version — left here for comparison
func validateBuggy(n int) error {
    var err *AppError        // typed nil: *AppError, value == nil
    if n < 0 {
        err = &AppError{Code: 400, Message: "negative value not allowed"}
    }
    return err
    // When n >= 0: returns interface{type=*AppError, value=nil}
    // This interface is NOT nil — the type field is set.
    // caller's "if err != nil" is ALWAYS true.
}

// CORRECT version — return untyped nil directly
func validate(n int) error {
    if n < 0 {
        return &AppError{Code: 400, Message: "negative value not allowed"}
    }
    return nil // interface{type=nil, value=nil} — truly nil
}

func main() {
    // Demonstrate the bug:
    err := validateBuggy(5)
    fmt.Printf("buggy validate(5):  err == nil? %v  (BUG: should be true)\n", err == nil)

    // Demonstrate the fix:
    err = validate(5)
    fmt.Printf("validate(5):  err == nil? %v   (correct)\n", err == nil)

    err = validate(-1)
    fmt.Printf("validate(-1): err == nil? %v  (correct, error: %v)\n", err == nil, err)
}

Scoring Log¶

Record your performance honestly. Include the date and whether you used hints.

Passing threshold: 9/14 (65%). Aim for 12/14 (85%) before taking the test.