Go Idioms

🧩 Go Idioms: The Art of Writing Beautiful Go Code

The LEGO Analogy 🧱

Imagine you have a giant box of LEGO bricks. Instead of buying one giant, fixed robot toy, you have small pieces that snap together in endless combinations. That’s exactly how Go works! Go loves small, simple pieces that combine to create powerful programs.

1. Composition Over Inheritance 🏗️

The Story

Think about building a superhero. In some worlds (like Java), you might say:

• “SuperHero inherits from Person, who inherits from LivingThing…”

But Go says: “Why not just snap abilities together like LEGO pieces?”

What Does This Mean?

Instead of creating a tall family tree of types, Go lets you embed smaller types inside bigger ones.

// Small LEGO pieces
type Engine struct {
    Horsepower int
}

type Wheels struct {
    Count int
}

// Snap them together!
type Car struct {
    Engine  // Embedded
    Wheels  // Embedded
    Brand string
}

Why It’s Amazing

Real Example

func main() {
    myCar := Car{
        Engine: Engine{Horsepower: 200},
        Wheels: Wheels{Count: 4},
        Brand:  "GoMobile",
    }

    // Access embedded fields directly!
    fmt.Println(myCar.Horsepower) // 200
    fmt.Println(myCar.Count)      // 4
}

💡 Key Insight: You don’t say “Car IS an Engine.” You say “Car HAS an Engine.” This makes your code flexible and easy to understand!

2. Functional Options Pattern 🎛️

The Story

You’re ordering a pizza. You could say:

• “I want pizza with cheese, no onions, extra sauce, thin crust…”

But what if you forget one option? What if you add new toppings later?

The Functional Options Pattern is like a pizza order form where each topping is a separate checkbox. Add what you want, skip what you don’t!

The Problem It Solves

// ❌ Too many parameters!
func NewServer(host string, port int,
    timeout int, maxConns int,
    tls bool, logger Logger) *Server

This is hard to read and easy to mess up!

The Solution

// ✅ Clean and flexible!
type Option func(*Server)

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

func WithTimeout(t int) Option {
    return func(s *Server) {
        s.timeout = t
    }
}

func NewServer(opts ...Option) *Server {
    s := &Server{port: 8080} // defaults
    for _, opt := range opts {
        opt(s)
    }
    return s
}

How to Use It

// Pick only what you need!
server := NewServer(
    WithPort(3000),
    WithTimeout(30),
)

Why It’s Brilliant

• ✅ Optional parameters - use only what you need
• ✅ Sensible defaults - works out of the box
• ✅ Easy to extend - add new options without breaking old code
• ✅ Self-documenting - WithTimeout(30) is crystal clear!

3. The slices Package 📦

The Story

Imagine you have a deck of cards. You want to:

• Sort them
• Find a specific card
• Remove duplicates
• Reverse the order

Before Go 1.21, you had to write all this yourself. Now? The slices package does it all!

Essential Functions

import "slices"

nums := []int{3, 1, 4, 1, 5, 9}

// Sort - arrange in order
slices.Sort(nums)
// Result: [1, 1, 3, 4, 5, 9]

// Contains - is it there?
found := slices.Contains(nums, 4)
// Result: true

// Index - where is it?
pos := slices.Index(nums, 5)
// Result: 4

// Reverse - flip it around
slices.Reverse(nums)
// Result: [9, 5, 4, 3, 1, 1]

More Power Tools

// Clone - make a copy
copy := slices.Clone(nums)

// Equal - are they the same?
same := slices.Equal(a, b)

// Compact - remove adjacent duplicates
unique := slices.Compact(sorted)

// Max and Min
biggest := slices.Max(nums)
smallest := slices.Min(nums)

graph TD
    A["Raw Slice"] --> B{What do you need?}
    B --> C["Sort"]
    B --> D["Search"]
    B --> E["Transform"]
    C --> F["slices.Sort"]
    D --> G["slices.Contains"]
    D --> H["slices.Index"]
    E --> I["slices.Reverse"]
    E --> J["slices.Clone"]

4. The maps Package 🗺️

The Story

A map is like a dictionary or a contact list. You look up a name, you get information back!

The maps package gives you superpowers for working with these key-value stores.

Essential Functions

import "maps"

scores := map[string]int{
    "Alice": 100,
    "Bob":   85,
    "Carol": 92,
}

// Clone - make a copy
backup := maps.Clone(scores)

// Copy - merge into another
maps.Copy(target, scores)

// Equal - compare two maps
same := maps.Equal(map1, map2)

// DeleteFunc - remove with condition
maps.DeleteFunc(scores, func(k string, v int) bool {
    return v < 90  // Remove low scores
})

Getting Keys and Values

// Get all keys
for key := range maps.Keys(scores) {
    fmt.Println(key)
}

// Get all values
for val := range maps.Values(scores) {
    fmt.Println(val)
}

💡 Pro Tip: maps.Clone() makes a shallow copy. For nested maps, you’ll need custom logic!

5. The cmp Package ⚖️

The Story

How do you compare things? Is 5 bigger than 3? Is “apple” before “banana” alphabetically?

The cmp package gives you two simple, powerful functions.

Compare Function

import "cmp"

// Returns: -1, 0, or 1
result := cmp.Compare(5, 3)
// Result: 1 (5 is greater)

result := cmp.Compare(3, 5)
// Result: -1 (3 is less)

result := cmp.Compare(5, 5)
// Result: 0 (equal)

Or Function (Pick Non-Zero)

// Returns first non-zero value
val := cmp.Or(0, 0, 42, 100)
// Result: 42

// Great for defaults!
port := cmp.Or(userPort, envPort, 8080)

When to Use

graph TD
    A["Need to Compare?"] --> B{What type?}
    B --> C["Numbers/Strings"]
    C --> D["cmp.Compare"]
    A --> E["Need Default?"]
    E --> F["cmp.Or"]

6. The clear Builtin 🧹

The Story

Imagine your whiteboard is full of old notes. Instead of erasing each one, you just… wipe the whole thing clean!

That’s what clear() does for slices and maps.

For Slices

nums := []int{1, 2, 3, 4, 5}

clear(nums)
// nums is now: [0, 0, 0, 0, 0]
// Length stays the same!
// Values become zero

For Maps

scores := map[string]int{
    "Alice": 100,
    "Bob":   85,
}

clear(scores)
// scores is now: map[]
// All entries removed!

Key Difference

⚠️ Remember: For slices, clear doesn’t change the length. It just sets every value to zero!

7. min and max Builtins 📊

The Story

“Who’s the tallest? Who scored highest? What’s the smallest number?”

Before Go 1.21, you had to write your own functions or import packages. Now it’s built right in!

Simple Usage

// Find the biggest
biggest := max(10, 5, 8, 3)
// Result: 10

// Find the smallest
smallest := min(10, 5, 8, 3)
// Result: 3

Works with Multiple Types

// Integers
m := max(1, 2, 3)

// Floats
m := max(1.5, 2.7, 0.9)

// Strings (alphabetically)
m := max("apple", "banana", "cherry")
// Result: "cherry"

Any Number of Arguments

// Two values
max(a, b)

// Many values!
max(a, b, c, d, e, f, g)

💡 Note: You need at least ONE argument. max() with no arguments won’t compile!

8. Range Over Integers 🔢

The Story

You want to count: “1, 2, 3, 4, 5…”

Old way? Create a slice or use a traditional for loop. New way? Just range over the number!

The Magic

// Print 0 to 4
for i := range 5 {
    fmt.Println(i)
}
// Output: 0, 1, 2, 3, 4

Before vs After

// ❌ Old way
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// ✅ New way (Go 1.22+)
for i := range 5 {
    fmt.Println(i)
}

When It’s Perfect

// Repeat something 3 times
for range 3 {
    fmt.Println("Hello!")
}

// Generate indices
for i := range 10 {
    process(i)
}

Important Notes

• Range starts at 0
• Range goes up to n-1
• Use range n when you need the index
• Use for range n (no variable) when you just need repetition

graph TD
    A["range 5"] --> B["i = 0"]
    B --> C["i = 1"]
    C --> D["i = 2"]
    D --> E["i = 3"]
    E --> F["i = 4"]
    F --> G["Done!"]

🎯 Summary: Your Go Idioms Toolkit

🚀 You Did It!

You now know the essential Go idioms that make your code:

• ✨ More readable
• 🔧 More maintainable
• 🚀 More Go-like

These aren’t just fancy tricks—they’re the building blocks that professional Go developers use every day. Start using them, and your code will feel cleaner and more powerful!

💪 Remember: Go is about simplicity and clarity. These idioms help you write code that’s not just correct—it’s beautiful.