go

name	go
description	Go programming patterns and idioms
domain	programming-languages
version	1.0.0
tags	["go","golang","concurrency","goroutines","channels"]
triggers	{"keywords":{"primary":["go","golang","goroutine","channel","go mod"],"secondary":["concurrency","defer","interface","struct","gin","echo"]},"context_boost":["backend","microservice","cli","cloud","kubernetes"],"context_penalty":["python","javascript","rust","java"],"priority":"high"}

Go

Overview

Go programming patterns including concurrency, error handling, and idiomatic Go code.

---

Basic Patterns

Structs and Methods

package main

import (
	"encoding/json"
	"fmt"
	"time"
)

// Struct definition
type User struct {
	ID        string    `json:"id"`
	Email     string    `json:"email"`
	Name      string    `json:"name"`
	CreatedAt time.Time `json:"created_at"`
	metadata  map[string]interface{} // unexported (private)
}

// Constructor function
func NewUser(email, name string) *User {
	return &User{
		ID:        generateID(),
		Email:     email,
		Name:      name,
		CreatedAt: time.Now(),
		metadata:  make(map[string]interface{}),
	}
}

// Value receiver (for read-only)
func (u User) FullName() string {
	return u.Name
}

// Pointer receiver (for mutations or large structs)
func (u *User) SetMetadata(key string, value interface{}) {
	u.metadata[key] = value
}

// Embedding (composition)
type Admin struct {
	User        // Embedded struct
	Permissions []string
}

func (a *Admin) HasPermission(perm string) bool {
	for _, p := range a.Permissions {
		if p == perm {
			return true
		}
	}
	return false
}

Interfaces

// Interface definition
type Repository interface {
	Find(id string) (*User, error)
	FindAll() ([]*User, error)
	Create(user *User) error
	Update(user *User) error
	Delete(id string) error
}

// Interface implementation (implicit)
type MemoryRepository struct {
	users map[string]*User
}

func NewMemoryRepository() *MemoryRepository {
	return &MemoryRepository{
		users: make(map[string]*User),
	}
}

func (r *MemoryRepository) Find(id string) (*User, error) {
	user, ok := r.users[id]
	if !ok {
		return nil, ErrNotFound
	}
	return user, nil
}

func (r *MemoryRepository) Create(user *User) error {
	r.users[user.ID] = user
	return nil
}

// Compile-time interface check
var _ Repository = (*MemoryRepository)(nil)

// Empty interface (any type)
func PrintAny(v interface{}) {
	fmt.Printf("%v\n", v)
}

// Type assertion
  {
	 val := v.() {
	 :
		fmt.Println(, val)
	 :
		fmt.Println(, val)
	 *User:
		fmt.Println(, val.Name)
	:
		fmt.Println()
	}
}

---

Error Handling

import (
	"errors"
	"fmt"
)

// Sentinel errors
var (
	ErrNotFound   = errors.New("not found")
	ErrBadRequest = errors.New("bad request")
)

// Custom error type
type ValidationError struct {
	Field   string
	Message string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("validation error on %s: %s", e.Field, e.Message)
}

// Error wrapping
func GetUser(id string) (*User, error) {
	user, err := repository.Find(id)
	if err != nil {
		return nil, fmt.Errorf("getting user %s: %w", id, err)
	}
	return user, nil
}

// Error checking
func ProcessUser(id string) error {
	user, err := GetUser(id)
	if err != nil {
		if errors.Is(err, ErrNotFound) {
			return fmt.Errorf("user not found: %s", id)
		}
		var validationErr *ValidationError
		if errors.As(err, &validationErr) {
			return fmt.Errorf("validation failed: %s", validationErr.Field)
		}
		return err
	}
	
	 
}


 MultiError  {
	Errors []
}

 Error()  {
	 msgs []
	 _, err :=  m.Errors {
		msgs = (msgs, err.Error())
	}
	 strings.Join(msgs, )
}

 Add(err ) {
	 err !=  {
		m.Errors = (m.Errors, err)
	}
}

 HasErrors()  {
	 (m.Errors) > 
}

---

Concurrency

Goroutines and Channels

// Basic goroutine
func main() {
	go func() {
		fmt.Println("Hello from goroutine")
	}()

	time.Sleep(100 * time.Millisecond)
}

// Channel basics
func worker(jobs <-chan int, results chan<- int) {
	for job := range jobs {
		results <- job * 2
	}
}

func main() {
	jobs := make(chan int, 100)
	results := make(chan int, 100)

	// Start workers
	for w := 0; w < 3; w++ {
		go worker(jobs, results)
	}

	// Send jobs
	for j := 0; j < 9; j++ {
		jobs <- j
	}
	close(jobs)

	// Collect results
	for r := 0; r < 9; r++ {
		fmt.Println(<-results)
	}
}

// Select for multiple channels
func main() {
	ch1 := make( )
	ch2 := ( )

	  {
		time.Sleep( * time.Millisecond)
		ch1 <- 
	}()

	  {
		time.Sleep( * time.Millisecond)
		ch2 <- 
	}()

	 i := ; i < ; i++ {
		 {
		 msg1 := <-ch1:
			fmt.Println(, msg1)
		 msg2 := <-ch2:
			fmt.Println(, msg2)
		 <-time.After( * time.Millisecond):
			fmt.Println()
		}
	}
}

Concurrency Patterns

import (
	"context"
	"sync"
)

// Worker pool
type WorkerPool struct {
	numWorkers int
	jobs       chan func()
	wg         sync.WaitGroup
}

func NewWorkerPool(numWorkers int) *WorkerPool {
	pool := &WorkerPool{
		numWorkers: numWorkers,
		jobs:       make(chan func(), numWorkers*2),
	}
	pool.Start()
	return pool
}

func (p *WorkerPool) Start() {
	for i := 0; i < p.numWorkers; i++ {
		go func() {
			for job := range p.jobs {
				job()
				p.wg.Done()
			}
		}()
	}
}

func (p *WorkerPool) Submit(job func()) {
	p.wg.Add(1)
	p.jobs <- job
}

func (p *WorkerPool) Wait() {
	p.wg.Wait()
}

func (p *WorkerPool) Close() {
	close(p.jobs)
}

// Fan-out, fan-in
func FanOut(ctx context.Context, input <-chan , workers ) []<-  {
	outputs := ([]<- , workers)
	 i := ; i < workers; i++ {
		outputs[i] = worker(ctx, input)
	}
	 outputs
}

 <-  {
	 wg sync.WaitGroup
	merged := ( )

	output :=  {
		 wg.Done()
		 v :=  c {
			 {
			 merged <- v:
			 <-ctx.Done():
				
			}
		}
	}

	wg.Add((channels))
	 _, c :=  channels {
		 output(c)
	}

	  {
		wg.Wait()
		(merged)
	}()

	 merged
}


 RateLimiter  {
	ticker *time.Ticker
	tokens  {}
}

 *RateLimiter {
	rl := &RateLimiter{
		ticker: time.NewTicker(time.Second / time.Duration(rate)),
		tokens: ( {}, burst),
	}

	
	 i := ; i < burst; i++ {
		rl.tokens <- {}{}
	}

	
	  {
		  rl.ticker.C {
			 {
			 rl.tokens <- {}{}:
			:
			}
		}
	}()

	 rl
}

 Wait(ctx context.Context)  {
	 {
	 <-rl.tokens:
		 
	 <-ctx.Done():
		 ctx.Err()
	}
}

---

Context

import (
	"context"
	"time"
)

// Context with timeout
func FetchWithTimeout(url string) ([]byte, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
	if err != nil {
		return nil, err
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	return io.ReadAll(resp.Body)
}

// Context with values
type contextKey string

const userIDKey contextKey = "userID"

func WithUserID(ctx context.Context, userID string) context.Context {
	return context.WithValue(ctx, userIDKey, userID)
}

func GetUserID(ctx context.Context) (string, bool) {
	userID, ok := ctx.Value(userIDKey).(string)
	return userID, ok
}

// Passing context through layers
func Handler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	ctx = WithUserID(ctx, r.Header.Get())

	result, err := ProcessRequest(ctx)
	 err !=  {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		
	}

	json.NewEncoder(w).Encode(result)
}

 (*Result, ) {
	
	 {
	 <-ctx.Done():
		 , ctx.Err()
	:
	}

	userID, ok := GetUserID(ctx)
	 !ok {
		 , errors.New()
	}

	 fetchData(ctx, userID)
}

---

Generics (Go 1.18+)

// Generic function
func Map[T, U any](items []T, fn func(T) U) []U {
	result := make([]U, len(items))
	for i, item := range items {
		result[i] = fn(item)
	}
	return result
}

func Filter[T any](items []T, predicate func(T) bool) []T {
	var result []T
	for _, item := range items {
		if predicate(item) {
			result = append(result, item)
		}
	}
	return result
}

func Reduce[T, U any](items []T, initial U, fn func(U, T) U) U {
	result := initial
	for _, item := range items {
		result = fn(result, item)
	}
	return result
}

// Generic type constraint
type Number interface {
	~int | ~int32 | ~int64 | ~float32 | ~float64
}

func Sum[T Number](items []T) T {
	var sum T
	for _, item :=  items {
		sum += item
	}
	 sum
}


 Stack[T any]  {
	items []T
}

 Push(item T) {
	s.items = (s.items, item)
}

 Pop() (T, ) {
	 (s.items) ==  {
		 zero T
		 zero, 
	}
	item := s.items[(s.items)]
	s.items = s.items[:(s.items)]
	 item, 
}


stack := &Stack[]{}
stack.Push()
stack.Push()
val, ok := stack.Pop() 

---

Testing

import (
	"testing"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// Basic test
func TestSum(t *testing.T) {
	result := Sum([]int{1, 2, 3})
	if result != 6 {
		t.Errorf("expected 6, got %d", result)
	}
}

// Table-driven tests
func TestSumTableDriven(t *testing.T) {
	tests := []struct {
		name     string
		input    []int
		expected int
	}{
		{"empty", []int{}, 0},
		{"single", []int{5}, 5},
		{"multiple", []int{1, 2, 3}, 6},
		{"negative", []int{-1, 1}, 0},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := Sum(tt.input)
			assert.Equal(t, tt.expected, result)
		})
	}
}

// Test with testify
func TestUser(t *testing.T) {
	user := NewUser(, )

	require.NotNil(t, user)
	assert.Equal(t, , user.Email)
	assert.Equal(t, , user.Name)
	assert.NotEmpty(t, user.ID)
}


 {
	items := ([], )
	 i :=  items {
		items[i] = i
	}

	b.ResetTimer()
	 i := ; i < b.N; i++ {
		Sum(items)
	}
}

---

Related Skills

• [[backend]] - Go web services
• [[cloud-platforms]] - Cloud-native Go
• [[system-design]] - System architecture