Go Modules & Workspace

// This is an annotated go.mod — not valid Go syntax,
// but shows the structure of a real go.mod file.
//
// File: go.mod (lives at the root of your module)

// module declares this module's canonical import path.
// All packages in this repo are imported as:
//   github.com/example/myapp/pkg/something
module github.com/example/myapp

// go specifies the minimum Go toolchain version.
// Features above this version will cause compile errors
// on older toolchains.
go 1.22

// require lists direct and indirect dependencies.
// Go uses Minimum Version Selection (MVS): it picks the
// minimum version that satisfies all constraints.
require (
    github.com/gin-gonic/gin v1.9.1
    golang.org/x/sync v0.6.0

    // indirect: required transitively, not directly imported
    github.com/bytedance/sonic v1.10.0 // indirect
)

// replace swaps a module for a local fork during development
// replace github.com/original/lib => ../local-lib

// exclude prevents a specific known-bad version from being used
// exclude github.com/bad/pkg v1.0.0

package main

// After running: go get golang.org/x/text/cases
// go.mod gains:  require golang.org/x/text v0.14.0
// go.sum gains:  hash entries for the module

// Standard library imports — no module needed
import (
    "fmt"
    "strings"
)

// Simulating what an external package import looks like
// (golang.org/x/text/cases would provide Unicode-aware casing)

// Without the real package, we demonstrate the pattern:
func titleCase(s string) string {
    // Real code would use: cases.Title(language.English).String(s)
    words := strings.Fields(s)
    for i, w := range words {
        if len(w) > 0 {
            words[i] = strings.ToUpper(w[:1]) + strings.ToLower(w[1:])
        }
    }
    return strings.Join(words, " ")
}

func main() {
    // go get workflow:
    // 1. go get github.com/some/pkg@v1.2.3
    // 2. import "github.com/some/pkg" in your code
    // 3. go mod tidy  (removes unused, adds missing)
    // 4. go build ./...

    samples := []string{
        "hello world",
        "the quick brown fox",
        "go modules are great",
    }

    for _, s := range samples {
        fmt.Printf("%-30s -> %s\n", s, titleCase(s))
    }
}

package main

import "fmt"

// Demonstrating the replace directive pattern.
//
// Scenario: your app depends on github.com/acme/logger,
// but you need to patch it locally before the fix is merged.
//
// go.mod entries:
//
//   require github.com/acme/logger v1.3.0
//
//   replace github.com/acme/logger => ../logger-fork
//
// go.work (workspace file) for multi-module development:
//
//   go 1.22
//   use (
//       ./myapp
//       ./logger-fork
//   )
//   // No replace needed — workspace redirects automatically

// Simulating the replaced package behaviour
type Logger interface {
    Info(msg string)
    Error(msg string)
}

// This would normally come from the replaced module
type PatchedLogger struct{ prefix string }

func (l *PatchedLogger) Info(msg string) {
    fmt.Printf("[INFO]  %s: %s\n", l.prefix, msg)
}
func (l *PatchedLogger) Error(msg string) {
    fmt.Printf("[ERROR] %s: %s\n", l.prefix, msg)
}

func NewLogger(prefix string) Logger {
    return &PatchedLogger{prefix: prefix}
}

func main() {
    log := NewLogger("app")
    log.Info("starting up")
    log.Info("loaded config")
    log.Error("database connection failed")

    fmt.Println()
    fmt.Println("Module commands cheat-sheet:")
    fmt.Println("  go mod init github.com/you/project")
    fmt.Println("  go get github.com/pkg@v1.2.3")
    fmt.Println("  go mod tidy")
    fmt.Println("  go mod vendor")
    fmt.Println("  go work init ./app ./lib")
}