package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}

package main
 
import (
    "fmt"
    "math"
)
 
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
 
// 名前付き戻り値を使ったバリエーション
func safeSqrt(x float64) (result float64, err error) {
    if x < 0 {
        err = fmt.Errorf("cannot take square root of negative number: %f", x)
        return // result=0.0, err=上記のエラー
    }
    result = math.Sqrt(x)
    return // result=計算結果, err=nil
}
 
func main() {
    // 複数戻り値の受け取り
    result, err := divide(10, 3)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("10 / 3 = %.4f\n", result)
 
    // 名前付き戻り値の関数
    sqrt, err := safeSqrt(16)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("sqrt(16) = %.1f\n", sqrt)
 
    // エラーケースの確認
    _, err = safeSqrt(-4)
    if err != nil {
        fmt.Printf("Expected error: %v\n", err)
    }
}

package main
 
import (
    "fmt"
    "strings"
)
 
// Server はHTTPサーバーの設定を表す構造体
type Server struct {
    Host     string
    Port     int
    TLS      bool
    CertFile string
    KeyFile  string
}
 
// Address は接続先アドレスを返す（値レシーバ）
func (s Server) Address() string {
    return fmt.Sprintf("%s:%d", s.Host, s.Port)
}
 
// URL は完全なURLを返す（値レシーバ）
func (s Server) URL() string {
    scheme := "http"
    if s.TLS {
        scheme = "https"
    }
    return fmt.Sprintf("%s://%s", scheme, s.Address())
}
 
// String は fmt.Stringer インターフェースを実装
func (s Server) String() string {
    var parts []string
    parts = append(parts, fmt.Sprintf("host=%s", s.Host))
    parts = append(parts, fmt.Sprintf("port=%d", s.Port))
    if s.TLS {
        parts = append(parts, "tls=enabled")
    }
    return fmt.Sprintf("Server{%s}", strings.Join(parts, ", "))
}
 
// EnableTLS はTLSを有効化する（ポインタレシーバ -- 構造体を変更）
func (s *Server) EnableTLS(certFile, keyFile string) {
    s.TLS = true
    s.CertFile = certFile
    s.KeyFile = keyFile
}
 
func main() {
    srv := Server{Host: "localhost", Port: 8080}
    fmt.Println(srv)           // Server{host=localhost, port=8080}
    fmt.Println(srv.URL())     // http://localhost:8080
 
    srv.EnableTLS("/etc/certs/cert.pem", "/etc/certs/key.pem")
    fmt.Println(srv)           // Server{host=localhost, port=8080, tls=enabled}
    fmt.Println(srv.URL())     // https://localhost:8080
}

package main
 
import (
    "fmt"
    "io"
    "strings"
)
 
// Writer インターフェース（io.Writerと同じシグネチャ）
type Writer interface {
    Write(p []byte) (n int, err error)
}
 
// 構造体が暗黙的にインターフェースを満たす -- 宣言不要
type FileWriter struct {
    Path string
}
 
func (fw FileWriter) Write(p []byte) (int, error) {
    fmt.Printf("[FileWriter] writing %d bytes to %s\n", len(p), fw.Path)
    return len(p), nil
}
 
// ConsoleWriter も同じインターフェースを満たす
type ConsoleWriter struct {
    Prefix string
}
 
func (cw ConsoleWriter) Write(p []byte) (int, error) {
    fmt.Printf("[%s] %s", cw.Prefix, string(p))
    return len(p), nil
}
 
// インターフェースの合成
type ReadWriteCloser interface {
    io.Reader
    io.Writer
    io.Closer
}
 
// 多態性の活用: Writer を受け取る関数
func writeMessage(w Writer, msg string) error {
    _, err := w.Write([]byte(msg))
    return err
}
 
// 空インターフェースとany
func printType(v any) {
    fmt.Printf("type=%T, value=%v\n", v, v)
}
 
func main() {
    // FileWriter と ConsoleWriter は同じインターフェースを満たす
    var w Writer
 
    w = FileWriter{Path: "/tmp/log.txt"}
    writeMessage(w, "hello from file writer\n")
 
    w = ConsoleWriter{Prefix: "CONSOLE"}
    writeMessage(w, "hello from console writer\n")
 
    // 標準ライブラリの strings.Reader も io.Reader を満たす
    reader := strings.NewReader("Go is great!")
    buf := make([]byte, 12)
    n, _ := reader.Read(buf)
    fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
}

package main
 
import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)
 
// ワーカーパターン: 複数のgoroutineでタスクを処理
func worker(id int, tasks <-chan int, results chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()
    for task := range tasks {
        // シミュレートされた処理
        duration := time.Duration(rand.Intn(100)) * time.Millisecond
        time.Sleep(duration)
        results <- fmt.Sprintf("worker %d processed task %d in %v", id, task, duration)
    }
}
 
func main() {
    // チャネルの基本
    ch := make(chan string)
    go func() {
        ch <- "hello from goroutine"
    }()
    msg := <-ch
    fmt.Println(msg)
 
    // ワーカープール
    const numWorkers = 3
    const numTasks = 10
 
    tasks := make(chan int, numTasks)
    results := make(chan string, numTasks)
 
    var wg sync.WaitGroup
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go worker(i, tasks, results, &wg)
    }
 
    // タスクを送信
    for i := 0; i < numTasks; i++ {
        tasks <- i
    }
    close(tasks) // 全タスク送信後にクローズ
 
    // 結果を別のgoroutineで収集
    go func() {
        wg.Wait()
        close(results) // 全ワーカー完了後にクローズ
    }()
 
    // 結果を表示
    for result := range results {
        fmt.Println(result)
    }
}

package main
 
import (
    "fmt"
    "os"
)
 
// deferの基本: LIFO順で実行される
func deferExample() {
    fmt.Println("start")
    defer fmt.Println("deferred 1")
    defer fmt.Println("deferred 2")
    defer fmt.Println("deferred 3")
    fmt.Println("end")
    // 出力: start, end, deferred 3, deferred 2, deferred 1
}
 
// deferでファイルクローズ（リソース管理の典型パターン）
func readFile(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, fmt.Errorf("open %s: %w", path, err)
    }
    defer f.Close() // 関数終了時に必ずクローズ
 
    info, err := f.Stat()
    if err != nil {
        return nil, fmt.Errorf("stat %s: %w", path, err)
    }
 
    buf := make([]byte, info.Size())
    _, err = f.Read(buf)
    if err != nil {
        return nil, fmt.Errorf("read %s: %w", path, err)
    }
    return buf, nil
}
 
// panic/recover: ライブラリ境界でのパニック回復
func safeDivide(a, b int) (result int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("recovered from panic: %v", r)
        }
    }()
 
    // bが0の場合、整数除算はpanicする
    return a / b, nil
}
 
func main() {
    deferExample()
 
    result, err := safeDivide(10, 0)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }
 
    result, err = safeDivide(10, 3)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
    } else {
        fmt.Printf("Result: %d\n", result)
    }
}

package main
 
import (
    "fmt"
    "sort"
    "strings"
)
 
func main() {
    // スライスの基本操作
    numbers := []int{5, 3, 8, 1, 9, 2, 7}
 
    // ソート
    sort.Ints(numbers)
    fmt.Println("sorted:", numbers)
 
    // append
    numbers = append(numbers, 10, 11)
    fmt.Println("appended:", numbers)
 
    // スライス式
    first3 := numbers[:3]
    last3 := numbers[len(numbers)-3:]
    fmt.Println("first 3:", first3)
    fmt.Println("last 3:", last3)
 
    // make でサイズ指定
    buf := make([]byte, 0, 1024) // length=0, capacity=1024
    buf = append(buf, "hello"...)
    fmt.Printf("buf: %s (len=%d, cap=%d)\n", buf, len(buf), cap(buf))
 
    // マップの基本操作
    scores := map[string]int{
        "Alice": 95,
        "Bob":   87,
        "Carol": 92,
    }
 
    // 要素の追加と取得
    scores["Dave"] = 88
 
    // 存在チェック
    if score, ok := scores["Eve"]; ok {
        fmt.Printf("Eve's score: %d\n", score)
    } else {
        fmt.Println("Eve not found")
    }
 
    // 削除
    delete(scores, "Bob")
 
    // マップの走査（順序は非決定的）
    for name, score := range scores {
        fmt.Printf("%s: %d\n", name, score)
    }
 
    // 文字列操作
    text := "Go is a statically typed, compiled language"
    words := strings.Fields(text)
    fmt.Printf("Word count: %d\n", len(words))
    fmt.Printf("Contains 'typed': %v\n", strings.Contains(text, "typed"))
    fmt.Printf("Upper: %s\n", strings.ToUpper(text))
}

package main
 
import (
    "fmt"
    "golang.org/x/exp/constraints"
)
 
// 型パラメータを持つ関数
func MinT constraints.Ordered T {
    if a < b {
        return a
    }
    return b
}
 
func MaxT constraints.Ordered T {
    if a > b {
        return a
    }
    return b
}
 
// ジェネリックなスライス操作
func FilterT any bool) []T {
    var result []T
    for _, v := range slice {
        if predicate(v) {
            result = append(result, v)
        }
    }
    return result
}
 
func MapT any, U any U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = transform(v)
    }
    return result
}
 
func ReduceT any, U any U) U {
    result := initial
    for _, v := range slice {
        result = reducer(result, v)
    }
    return result
}
 
// 型制約の定義
type Number interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
        ~float32 | ~float64
}
 
func SumT Number T {
    var total T
    for _, n := range numbers {
        total += n
    }
    return total
}
 
// ジェネリックなデータ構造
type Stack[T any] struct {
    items []T
}
 
func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}
 
func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}
 
func (s *Stack[T]) Peek() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    return s.items[len(s.items)-1], true
}
 
func (s *Stack[T]) Len() int {
    return len(s.items)
}
 
func main() {
    // 型推論でジェネリック関数を呼び出し
    fmt.Println(Min(3, 7))         // 3
    fmt.Println(Min("apple", "banana")) // "apple"
    fmt.Println(Max(3.14, 2.71))   // 3.14
 
    // Filter/Map/Reduce
    numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 
    evens := Filter(numbers, func(n int) bool { return n%2 == 0 })
    fmt.Println("evens:", evens)
 
    doubled := Map(numbers, func(n int) int { return n * 2 })
    fmt.Println("doubled:", doubled)
 
    sum := Reduce(numbers, 0, func(acc, n int) int { return acc + n })
    fmt.Println("sum:", sum)
 
    // ジェネリックStack
    stack := &Stack[string]{}
    stack.Push("first")
    stack.Push("second")
    stack.Push("third")
 
    for stack.Len() > 0 {
        if item, ok := stack.Pop(); ok {
            fmt.Println("popped:", item)
        }
    }
}

package main
 
import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
)
 
// User はユーザー情報を表す
type User struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Email     string    `json:"email"`
    CreatedAt time.Time `json:"created_at"`
}
 
// インメモリストア
type UserStore struct {
    mu    sync.RWMutex
    users map[int]*User
    nextID int
}
 
func NewUserStore() *UserStore {
    return &UserStore{
        users:  make(map[int]*User),
        nextID: 1,
    }
}
 
func (s *UserStore) Create(name, email string) *User {
    s.mu.Lock()
    defer s.mu.Unlock()
    user := &User{
        ID:        s.nextID,
        Name:      name,
        Email:     email,
        CreatedAt: time.Now(),
    }
    s.users[user.ID] = user
    s.nextID++
    return user
}
 
func (s *UserStore) List() []*User {
    s.mu.RLock()
    defer s.mu.RUnlock()
    users := make([]*User, 0, len(s.users))
    for _, u := range s.users {
        users = append(users, u)
    }
    return users
}
 
func main() {
    store := NewUserStore()
 
    // サンプルデータ
    store.Create("Alice", "alice@example.com")
    store.Create("Bob", "bob@example.com")
 
    // ルーティング（Go 1.22+ のパターンマッチング）
    mux := http.NewServeMux()
 
    mux.HandleFunc("GET /api/users", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(store.List())
    })
 
    mux.HandleFunc("POST /api/users", func(w http.ResponseWriter, r *http.Request) {
        var input struct {
            Name  string `json:"name"`
            Email string `json:"email"`
        }
        if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
            http.Error(w, "invalid request body", http.StatusBadRequest)
            return
        }
        user := store.Create(input.Name, input.Email)
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(user)
    })
 
    mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "OK")
    })
 
    // ミドルウェア: ロギング
    handler := loggingMiddleware(mux)
 
    server := &http.Server{
        Addr:         ":8080",
        Handler:      handler,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  120 * time.Second,
    }
 
    log.Printf("Starting server on %s", server.Addr)
    log.Fatal(server.ListenAndServe())
}
 
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
    })
}

package main
 
import (
    "testing"
)
 
// テスト対象の関数
func Add(a, b int) int {
    return a + b
}
 
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
 
// 基本的なテスト
func TestAdd(t *testing.T) {
    got := Add(2, 3)
    want := 5
    if got != want {
        t.Errorf("Add(2, 3) = %d; want %d", got, want)
    }
}
 
// テーブル駆動テスト（Go の標準パターン）
func TestDivide(t *testing.T) {
    tests := []struct {
        name    string
        a, b    float64
        want    float64
        wantErr bool
    }{
        {"normal division", 10, 3, 3.3333333333333335, false},
        {"exact division", 10, 2, 5.0, false},
        {"division by zero", 10, 0, 0, true},
        {"negative numbers", -10, 3, -3.3333333333333335, false},
        {"zero dividend", 0, 5, 0, false},
    }
 
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := Divide(tt.a, tt.b)
            if (err != nil) != tt.wantErr {
                t.Errorf("Divide(%v, %v) error = %v, wantErr %v",
                    tt.a, tt.b, err, tt.wantErr)
                return
            }
            if !tt.wantErr && got != tt.want {
                t.Errorf("Divide(%v, %v) = %v, want %v",
                    tt.a, tt.b, got, tt.want)
            }
        })
    }
}
 
// ベンチマーク
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(100, 200)
    }
}
 
// サブテスト、パラレルテスト
func TestAddParallel(t *testing.T) {
    t.Parallel()
    tests := []struct {
        a, b, want int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
        {1000000, 1000000, 2000000},
    }
 
    for _, tt := range tests {
        tt := tt // Go 1.21以前はキャプチャ必要
        t.Run(fmt.Sprintf("%d+%d", tt.a, tt.b), func(t *testing.T) {
            t.Parallel()
            if got := Add(tt.a, tt.b); got != tt.want {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.want)
            }
        })
    }
}

// BAD: init()で複雑な初期化をする
var db *sql.DB
 
func init() {
    db, _ = sql.Open("postgres", os.Getenv("DB_URL")) // エラー無視
    db.Ping()                                          // テスト困難
}
 
// 問題点:
// 1. エラーが無視される
// 2. テスト時にDB接続が必須になる
// 3. 初期化の順序が不明確
// 4. 環境変数への暗黙的な依存
 
// GOOD: 明示的に初期化関数を呼ぶ
func NewDB(url string) (*sql.DB, error) {
    db, err := sql.Open("postgres", url)
    if err != nil {
        return nil, fmt.Errorf("db open: %w", err)
    }
    if err := db.Ping(); err != nil {
        return nil, fmt.Errorf("db ping: %w", err)
    }
    return db, nil
}
 
// init() が適切な場面:
// - ドライバの登録: sql.Register(), image.RegisterFormat()
// - 定数の計算: 正規表現のコンパイル

// BAD: panicでエラーを伝搬
func MustParse(s string) int {
    v, err := strconv.Atoi(s)
    if err != nil {
        panic(err) // ライブラリがpanicするべきではない
    }
    return v
}
 
// Must パターンが許される場面:
// - main() やパッケージ初期化時の設定読み込み
// - テストヘルパー関数
// - template.Must() のようなグローバル定数初期化
 
// GOOD: エラーを返す
func Parse(s string) (int, error) {
    v, err := strconv.Atoi(s)
    if err != nil {
        return 0, fmt.Errorf("parse %q: %w", s, err)
    }
    return v, nil
}
 
// Must パターンを使う場合の安全な実装
func MustCompileRegex(pattern string) *regexp.Regexp {
    re, err := regexp.Compile(pattern)
    if err != nil {
        panic(fmt.Sprintf("regexp: Compile(%q): %v", pattern, err))
    }
    return re
}
 
// パッケージレベルで使用（init時に確定する値）
var emailRegex = MustCompileRegex(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)

// BAD: 使う前からインターフェースを定義（Java的な思考）
// producer側でインターフェースを定義
package storage
 
type Storage interface {  // 最初から大きなインターフェース
    Get(key string) ([]byte, error)
    Set(key, value string) error
    Delete(key string) error
    List(prefix string) ([]string, error)
    Watch(key string) <-chan Event
}
 
type S3Storage struct { /* ... */ }
// S3Storage implements Storage
 
// GOOD: consumer側で必要最小限のインターフェースを定義
package handler
 
// Getter は handler パッケージが必要とするインターフェース
type Getter interface {
    Get(key string) ([]byte, error)
}
 
// UserHandler は Storage の Get のみ必要
type UserHandler struct {
    store Getter  // 小さなインターフェース
}
 
func NewUserHandler(store Getter) *UserHandler {
    return &UserHandler{store: store}
}

// BAD: 至る所で context.Background() を使う
func fetchData() (*Data, error) {
    ctx := context.Background() // キャンセル不能
    resp, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    // ...
}
 
// GOOD: 呼び出し元から context を受け取る
func fetchData(ctx context.Context) (*Data, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, fmt.Errorf("create request: %w", err)
    }
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, fmt.Errorf("do request: %w", err)
    }
    defer resp.Body.Close()
    // ...
}
 
// context は関数の第一引数として渡すのが慣習
// func DoSomething(ctx context.Context, args ...T) error

// BAD: エラーを _ で無視
data, _ := json.Marshal(user)
_ = os.Remove(tmpFile)
fmt.Fprintf(w, "hello") // io.Writer のエラーを無視
 
// GOOD: 全てのエラーをチェック
data, err := json.Marshal(user)
if err != nil {
    return fmt.Errorf("marshal user: %w", err)
}
 
if err := os.Remove(tmpFile); err != nil {
    log.Printf("warning: failed to remove temp file: %v", err)
    // クリーンアップの失敗は致命的でなければログだけでOK
}
 
if _, err := fmt.Fprintf(w, "hello"); err != nil {
    return fmt.Errorf("write response: %w", err)
}

# macOS
brew install go
 
# Linux
wget https://go.dev/dl/go1.23.0.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.23.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin
 
# バージョン確認
go version
 
# 環境変数
go env GOPATH    # ワークスペースのパス
go env GOROOT    # Goのインストール先
go env GOPROXY   # モジュールプロキシ
 
# 新しいプロジェクトの作成
mkdir myproject && cd myproject
go mod init github.com/myorg/myproject

# ビルドとテスト
go build ./...              # 全パッケージをビルド
go test ./...               # 全テストを実行
go test -race ./...         # レースコンディション検出
go test -cover ./...        # カバレッジ付きテスト
go test -bench=. ./...      # ベンチマーク実行
go test -fuzz=FuzzXxx ./... # ファジングテスト (Go 1.18+)
 
# コード品質
go fmt ./...                # フォーマット
go vet ./...                # 静的解析
golangci-lint run ./...     # 複合リンター
 
# 依存関係管理
go mod tidy                 # 未使用の依存を削除、不足を追加
go mod download             # 依存をダウンロード
go mod vendor               # vendorディレクトリに依存をコピー
go mod graph                # 依存グラフを表示
 
# ドキュメントとプロファイリング
go doc fmt.Println          # ドキュメント表示
go tool pprof cpu.prof      # CPUプロファイル解析
go tool trace trace.out     # トレース解析

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

// GCチューニングの例
// GOGC=100 (デフォルト): ヒープが100%増加でGC実行
// GOGC=50: より頻繁にGC、メモリ使用量を抑える
// GOGC=200: GC頻度を下げ、CPUを節約
// GOMEMLIMIT=4GiB: ヒープの上限を設定
 
// プログラム内から確認
import "runtime/debug"
 
func init() {
    debug.SetGCPercent(100)
    debug.SetMemoryLimit(4 << 30) // 4 GiB
}

// インターフェースで依存を定義
type UserRepository interface {
    FindByID(ctx context.Context, id int) (*User, error)
}
 
type EmailSender interface {
    Send(ctx context.Context, to, subject, body string) error
}
 
// コンストラクタで注入
type UserService struct {
    repo   UserRepository
    mailer EmailSender
    logger *slog.Logger
}
 
func NewUserService(repo UserRepository, mailer EmailSender, logger *slog.Logger) *UserService {
    return &UserService{
        repo:   repo,
        mailer: mailer,
        logger: logger,
    }
}
 
// main() で組み立て（Composition Root）
func main() {
    db := connectDB()
    repo := postgres.NewUserRepository(db)
    mailer := smtp.NewEmailSender(smtpConfig)
    logger := slog.Default()
 
    svc := NewUserService(repo, mailer, logger)
    handler := NewUserHandler(svc)
    // ...
}

// ヘルパー関数でまとめる
func mustT any T {
    if err != nil {
        panic(err)
    }
    return v
}
 
// errWriter パターン（bufio.Scanner等で使用）
type errWriter struct {
    w   io.Writer
    err error
}
 
func (ew *errWriter) write(buf []byte) {
    if ew.err != nil {
        return
    }
    _, ew.err = ew.w.Write(buf)
}