// Example: Concurrent worker pool
type Task func() error

func WorkerPool(tasks []Task, workers int) []error {
    taskChan := make(chan Task, len(tasks))
    errChan := make(chan error, len(tasks))
    
    // Start workers
    var wg sync.WaitGroup
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for task := range taskChan {
                if err := task(); err != nil {
                    errChan <- err
                }
            }
        }()
    }
    
    // Send tasks
    for _, task := range tasks {
        taskChan <- task
    }
    close(taskChan)
    
    wg.Wait()
    close(errChan)
    
    // Collect errors
    var errors []error
    for err := range errChan {
        errors = append(errors, err)
    }
    return errors
}

// Example: Type-safe API client with generics
interface ApiResponse<T> {
  data: T;
  success: boolean;
  error?: string;
}

class ApiClient {
  constructor(private baseUrl: string) {}

  async fetch<T>(
    endpoint: string,
    options?: RequestInit
  ): Promise<ApiResponse<T>> {
    try {
      const response = await fetch(
        `${this.baseUrl}${endpoint}`,
        options
      );
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      
      const data = await response.json();
      return { data, success: true };
    } catch (error) {
      return {
        data: null as T,
        success: false,
        error: error.message
      };
    }
  }
}