Contrarian View: Rust 1.85 Is Not Worth the Learning Curve for Go 1.24 Devs in 2026

// Go 1.24 Generic REST API Example
// Demonstrates new Go 1.24 generic response wrapper and error handling improvements
package main

import (
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"net/http\"
    \"time\"

    \"github.com/gorilla/mux\" // canonical link: https://github.com/gorilla/mux
)

// GenericResponse wraps all API responses to reduce boilerplate (Go 1.24 generics improvement)
type GenericResponse[T any] struct {
    Success bool   `json:\"success\"`
    Data    T      `json:\"data,omitempty\"`
    Error   string `json:\"error,omitempty\"`
    Timestamp time.Time `json:\"timestamp\"`
}

// User represents a simple user resource
type User struct {
    ID    string `json:\"id\"`
    Name  string `json:\"name\"`
    Email string `json:\"email\"`
}

// In-memory user store (simplified for example)
var userStore = map[string]User{
    \"1\": {ID: \"1\", Name: \"Alice\", Email: \"alice@example.com\"},
    \"2\": {ID: \"2\", Name: \"Bob\", Email: \"bob@example.com\"},
}

// GetUserHandler returns a generic response with user data
func GetUserHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    userID := vars[\"id\"]

    // Error handling with Go 1.24's improved error wrapping
    user, exists := userStore[userID]
    if !exists {
        resp := GenericResponse[User]{
            Success: false,
            Error:   fmt.Errorf(\"user %s not found\", userID).Error(),
            Timestamp: time.Now(),
        }
        w.WriteHeader(http.StatusNotFound)
        json.NewEncoder(w).Encode(resp)
        return
    }

    // Success response with generic wrapper
    resp := GenericResponse[User]{
        Success: true,
        Data:    user,
        Timestamp: time.Now(),
    }
    w.Header().Set(\"Content-Type\", \"application/json\")
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(resp)
}

// HealthCheckHandler demonstrates zero-boilerplate health endpoints in Go 1.24
func HealthCheckHandler(w http.ResponseWriter, r *http.Request) {
    resp := GenericResponse[struct{}]{
        Success: true,
        Data:    struct{}{},
        Timestamp: time.Now(),
    }
    w.Header().Set(\"Content-Type\", \"application/json\")
    json.NewEncoder(w).Encode(resp)
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc(\"/users/{id}\", GetUserHandler).Methods(\"GET\")
    r.HandleFunc(\"/health\", HealthCheckHandler).Methods(\"GET\")

    srv := &http.Server{
        Handler:      r,
        Addr:         \":8080\",
        WriteTimeout: 15 * time.Second,
        ReadTimeout:  15 * time.Second,
    }

    log.Println(\"Go 1.24 API running on :8080\")
    log.Fatal(srv.ListenAndServe())
}

// Rust 1.85 REST API Example
// Equivalent functionality to the Go 1.24 example above
// Requires actix-web 4.5, serde 1.0, serde_json 1.0
use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{SystemTime, UNIX_EPOCH};

// Generic response wrapper (Rust 1.85 supports full generic impls)
#[derive(Serialize)]
struct GenericResponse {
    success: bool,
    #[serde(skip_serializing_if = \"Option::is_none\")]
    data: Option,
    #[serde(skip_serializing_if = \"Option::is_none\")]
    error: Option,
    timestamp: u64,
}

// User resource matching Go example
#[derive(Serialize, Deserialize, Clone)]
struct User {
    id: String,
    name: String,
    email: String,
}

// Shared user store wrapped in Arc for thread safety
type UserStore = Arc>>;

// Get user handler with full error handling
async fn get_user(
    user_store: web::Data,
    user_id: web::Path,
) -> impl Responder {
    let store = user_store.lock().unwrap();
    let user_id = user_id.into_inner();

    match store.get(&user_id) {
        Some(user) => {
            let resp = GenericResponse {
                success: true,
                data: Some(user.clone()),
                error: None,
                timestamp: SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap()
                    .as_secs(),
            };
            HttpResponse::Ok().json(resp)
        }
        None => {
            let resp = GenericResponse:: {
                success: false,
                data: None,
                error: Some(format!(\"user {} not found\", user_id)),
                timestamp: SystemTime::now()
                    .duration_since(UNIX_EPOCH)
                    .unwrap()
                    .as_secs(),
            };
            HttpResponse::NotFound().json(resp)
        }
    }
}

// Health check handler
async fn health_check() -> impl Responder {
    let resp = GenericResponse::<()> {
        success: true,
        data: Some(()),
        error: None,
        timestamp: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_secs(),
    };
    HttpResponse::Ok().json(resp)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // Initialize user store
    let mut store = HashMap::new();
    store.insert(
        \"1\".to_string(),
        User {
            id: \"1\".to_string(),
            name: \"Alice\".to_string(),
            email: \"alice@example.com\".to_string(),
        },
    );
    store.insert(
        \"2\".to_string(),
        User {
            id: \"2\".to_string(),
            name: \"Bob\".to_string(),
            email: \"bob@example.com\".to_string(),
        },
    );
    let user_store = web::Data::new(Arc::new(Mutex::new(store)));

    println!(\"Rust 1.85 API running on :8080\");

    HttpServer::new(move || {
        App::new()
            .app_data(user_store.clone())
            .route(\"/users/{id}\", web::get().to(get_user))
            .route(\"/health\", web::get().to(health_check))
    })
    .bind(\"0.0.0.0:8080\")?
    .run()
    .await
}

// Go 1.24 Concurrent Worker Pool Example
// Demonstrates Go 1.24's improved context cancellation and generic worker pools
package main

import (
    \"context\"
    \"encoding/csv\"
    \"fmt\"
    \"log\"
    \"os\"
    \"sync\"
    \"time\"

    \"github.com/pkg/errors\" // https://github.com/pkg/errors
)

// Job represents a CSV processing job
type Job struct {
    ID   int
    Path string
}

// Result represents the output of a processed job
type Result struct {
    JobID  int
    RowCount int
    Error  error
}

// WorkerPool is a generic pool for processing jobs (Go 1.24 generics)
type WorkerPool[J any, R any] struct {
    jobChan    chan J
    resultChan chan R
    workerFn   func(context.Context, J) (R, error)
    wg         sync.WaitGroup
}

// NewWorkerPool initializes a new worker pool with given concurrency
func NewWorkerPool[J any, R any](concurrency int, workerFn func(context.Context, J) (R, error)) *WorkerPool[J, R] {
    return &WorkerPool[J, R]{
        jobChan:    make(chan J, concurrency*2),
        resultChan: make(chan R, concurrency*2),
        workerFn:   workerFn,
    }
}

// Start launches the worker pool with context support (Go 1.24 improved context)
func (p *WorkerPool[J, R]) Start(ctx context.Context) {
    for i := 0; i < cap(p.jobChan)/2; i++ {
        p.wg.Add(1)
        go func(workerID int) {
            defer p.wg.Done()
            for job := range p.jobChan {
                // Check for context cancellation before processing
                select {
                case <-ctx.Done():
                    log.Printf(\"worker %d: context cancelled, stopping\", workerID)
                    return
                default:
                    // Process job
                    result, err := p.workerFn(ctx, job)
                    if err != nil {
                        log.Printf(\"worker %d: job %v failed: %v\", workerID, job, err)
                        continue
                    }
                    p.resultChan <- result
                }
            }
        }(i)
    }
}

// AddJob adds a job to the pool
func (p *WorkerPool[J, R]) AddJob(job J) {
    p.jobChan <- job
}

// GetResults returns the result channel
func (p *WorkerPool[J, R]) GetResults() <-chan R {
    return p.resultChan
}

// Stop waits for all workers to finish and closes channels
func (p *WorkerPool[J, R]) Stop() {
    close(p.jobChan)
    p.wg.Wait()
    close(p.resultChan)
}

// processCSV is the worker function for processing CSV files
func processCSV(ctx context.Context, job Job) (Result, error) {
    // Open file with error handling
    file, err := os.Open(job.Path)
    if err != nil {
        return Result{JobID: job.ID}, errors.Wrapf(err, \"failed to open file %s\", job.Path)
    }
    defer file.Close()

    // Read CSV
    reader := csv.NewReader(file)
    rows, err := reader.ReadAll()
    if err != nil {
        return Result{JobID: job.ID}, errors.Wrapf(err, \"failed to read CSV %s\", job.Path)
    }

    // Simulate processing time
    select {
    case <-ctx.Done():
        return Result{JobID: job.ID}, ctx.Err()
    case <-time.After(100 * time.Millisecond):
        // Continue
    }

    return Result{JobID: job.ID, RowCount: len(rows)}, nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // Initialize worker pool with 4 workers
    pool := NewWorkerPool[Job, Result](4, processCSV)
    go pool.Start(ctx)

    // Add jobs
    jobs := []Job{
        {ID: 1, Path: \"users.csv\"},
        {ID: 2, Path: \"orders.csv\"},
        {ID: 3, Path: \"products.csv\"},
    }
    for _, job := range jobs {
        pool.AddJob(job)
    }

    // Collect results
    go func() {
        for result := range pool.GetResults() {
            if result.Error != nil {
                log.Printf(\"job %d failed: %v\", result.JobID, result.Error)
                continue
            }
            fmt.Printf(\"job %d: processed %d rows\n\", result.JobID, result.RowCount)
        }
    }()

    // Wait for all jobs to finish
    time.Sleep(2 * time.Second)
    pool.Stop()
    fmt.Println(\"all jobs processed\")
}

// Generic error wrapper matching Rust's Result type
type Result[T any] struct {
    Value T
    Err   error
}

// Unwrap returns the value or panics with a typed error (matching Rust's unwrap)
func (r Result[T]) Unwrap() T {
    if r.Err != nil {
        panic(fmt.Sprintf(\"unwrap failed: %v\", r.Err))
    }
    return r.Value
}

// Map applies a function to the value if no error exists (matching Rust's Result.map)
func (r Result[T]) Map(f func(T) T) Result[T] {
    if r.Err != nil {
        return r
    }
    return Result[T]{Value: f(r.Value), Err: nil}
}

// Enable aggressive build caching in Go 1.24
// Run with: GOCACHE=/path/to/cache go build -a -v ./...
func init() {
    // Set build cache size to 10GB (default is 2GB)
    os.Setenv(\"GOCACHE_MAX_SIZE\", \"10737418240\")
    // Enable incremental compilation for test runs
    os.Setenv(\"GOINCREMENTAL\", \"1\")
}

// Compile to WASM with: GOOS=js GOARCH=wasm go build -o main.wasm ./...
package main

import \"syscall/js\"

func main() {
    // Register WASM function accessible from JavaScript
    js.Global().Set(\"processRequest\", js.FuncOf(func(this js.Value, args []js.Value) interface{} {
        return map[string]interface{}{
            \"status\": \"success\",
            \"data\":   args[0].String(),
        }
    }))
    // Keep goroutine alive
    select {}
}