go install golang.org/x/tools/cmd/godoc@latest

// Package calculator provides basic arithmetic operations.
// It supports addition, subtraction, multiplication, and division
// with proper error handling for edge cases like division by zero.
//
// Example usage:
//
//     result, err := calculator.Add(5, 3)
//     if err != nil {
//         log.Fatal(err)
//     }
//     fmt.Println(result) // Output: 8
//
package calculator

// Add returns the sum of two integers.
// It performs simple addition without overflow checking.
func Add(a, b int) int {
    return a + b
}

// Divide divides the numerator by the denominator.
// It returns an error if the denominator is zero.
func Divide(numerator, denominator float64) (float64, error) {
    if denominator == 0 {
        return 0, errors.New("division by zero")
    }
    return numerator / denominator, nil
}

// User represents a user in the system.
// It contains basic information needed for authentication and identification.
type User struct {
    // ID is the unique identifier for the user.
    ID int
    
    // Username is the user's login name.
    // It must be unique across the system.
    Username string
    
    // Email is the user's email address.
    // It's used for notifications and password recovery.
    Email string
    
    // CreatedAt is the timestamp when the user was created.
    CreatedAt time.Time
}

// MaxRetries is the maximum number of retry attempts for failed operations.
const MaxRetries = 3

// DefaultTimeout is the default timeout duration for network requests.
const DefaultTimeout = 30 * time.Second

// ErrNotFound is returned when a requested resource is not found.
var ErrNotFound = errors.New("resource not found")

// calculator_test.go 파일에 작성

package calculator_test

import (
    "fmt"
    "yourmodule/calculator"
)

// ExampleAdd demonstrates basic addition.
func ExampleAdd() {
    result := calculator.Add(2, 3)
    fmt.Println(result)
    // Output: 5
}

// ExampleDivide demonstrates division with error handling.
func ExampleDivide() {
    result, err := calculator.Divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(result)
    // Output: 5
}

# 현재 패키지의 문서 보기
go doc

# 특정 패키지의 문서 보기
go doc fmt

# 특정 함수의 문서 보기
go doc fmt.Println

# 더 자세한 정보 보기
go doc -all fmt

# godoc 웹 서버 시작 (기본 포트 6060)
godoc -http=:6060

# 다른 포트 사용
godoc -http=:8080

# 인덱스와 함께 서버 시작
godoc -http=:6060 -index

# 인덱스 업데이트 간격 설정 (기본 5분)
godoc -http=:6060 -index -index_interval=10m

myapi/
├── doc.go
├── server.go
├── handlers/
│   ├── doc.go
│   ├── user.go
│   └── user_test.go
├── models/
│   ├── doc.go
│   └── user.go
└── utils/
    ├── doc.go
    └── validator.go

// Package myapi provides a RESTful API server for user management.
//
// This package implements a complete HTTP server with endpoints for
// creating, reading, updating, and deleting user records. It includes
// input validation, error handling, and JSON serialization.
//
// # Architecture
//
// The API is organized into three main components:
//   - handlers: HTTP request handlers
//   - models: Data structures and business logic
//   - utils: Helper functions and utilities
//
// # Quick Start
//
// To start the server:
//
//     server := myapi.NewServer(":8080")
//     if err := server.Start(); err != nil {
//         log.Fatal(err)
//     }
//
// # API Endpoints
//
//     POST   /users      - Create a new user
//     GET    /users/:id  - Get user by ID
//     PUT    /users/:id  - Update user
//     DELETE /users/:id  - Delete user
//
// For more detailed information, see the handlers package.
package myapi

// Package handlers implements HTTP request handlers for the API.
package handlers

import (
    "encoding/json"
    "net/http"
    "myapi/models"
)

// UserHandler handles HTTP requests related to user operations.
// It provides methods for CRUD operations on user resources.
type UserHandler struct {
    store models.UserStore
}

// NewUserHandler creates a new UserHandler with the given store.
// The store parameter must not be nil.
func NewUserHandler(store models.UserStore) *UserHandler {
    return &UserHandler{store: store}
}

// CreateUser handles POST requests to create a new user.
// It expects a JSON payload with user information in the request body.
//
// Request body example:
//
//     {
//       "username": "john_doe",
//       "email": "john@example.com"
//     }
//
// Response codes:
//   - 201: User created successfully
//   - 400: Invalid request body or validation error
//   - 500: Internal server error
func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
    var user models.User
    
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        return
    }
    
    if err := h.store.Create(&user); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

// Package models defines data structures and business logic.
package models

import "time"

// User represents a user in the system.
// All fields are required unless marked as optional.
type User struct {
    // ID is the unique identifier for the user.
    // It's automatically generated when the user is created.
    ID int `json:"id"`
    
    // Username is the user's login name.
    // It must be unique and contain only alphanumeric characters.
    Username string `json:"username"`
    
    // Email is the user's email address.
    // It must be a valid email format.
    Email string `json:"email"`
    
    // CreatedAt is the timestamp when the user was created.
    CreatedAt time.Time `json:"created_at"`
    
    // UpdatedAt is the timestamp of the last update.
    // This field is optional and may be nil.
    UpdatedAt *time.Time `json:"updated_at,omitempty"`
}

// UserStore defines the interface for user data persistence.
// Implementations must be safe for concurrent use.
type UserStore interface {
    // Create adds a new user to the store.
    // It returns an error if the username or email already exists.
    Create(user *User) error
    
    // GetByID retrieves a user by their ID.
    // It returns ErrNotFound if the user doesn't exist.
    GetByID(id int) (*User, error)
    
    // Update modifies an existing user.
    // It returns ErrNotFound if the user doesn't exist.
    Update(user *User) error
    
    // Delete removes a user from the store.
    // It returns ErrNotFound if the user doesn't exist.
    Delete(id int) error
}

// ErrNotFound is returned when a requested user is not found.
var ErrNotFound = errors.New("user not found")

// user_test.go
package handlers_test

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "net/http/httptest"
    "myapi/handlers"
    "myapi/models"
)

// ExampleUserHandler_CreateUser demonstrates creating a new user.
func ExampleUserHandler_CreateUser() {
    // 테스트용 스토어 생성
    store := models.NewMemoryStore()
    handler := handlers.NewUserHandler(store)
    
    // 요청 생성
    user := models.User{
        Username: "testuser",
        Email:    "test@example.com",
    }
    body, _ := json.Marshal(user)
    req := httptest.NewRequest("POST", "/users", bytes.NewReader(body))
    w := httptest.NewRecorder()
    
    // 핸들러 실행
    handler.CreateUser(w, req)
    
    fmt.Println(w.Code)
    // Output: 201
}

// ExampleUser demonstrates basic user creation.
func ExampleUser() {
    user := models.User{
        ID:       1,
        Username: "john_doe",
        Email:    "john@example.com",
    }
    
    fmt.Printf("User: %s (%s)\n", user.Username, user.Email)
    // Output: User: john_doe (john@example.com)
}

// Process handles the data processing workflow.
// 
// Example usage:
//
//     processor := NewProcessor()
//     result, err := processor.Process(data)
//     if err != nil {
//         return err
//     }
//     fmt.Println(result)
//
// The processor supports multiple data formats including JSON and XML.
func Process(data []byte) ([]byte, error) {
    // implementation
}

// ParseUser parses user data from JSON.
// It uses the User type defined in the models package.
// Returns ErrInvalidFormat if the JSON is malformed.
//
// See also: User, ValidateUser, ErrInvalidFormat
func ParseUser(data []byte) (*User, error) {
    // implementation
}

// OldFunction does something in the old way.
//
// Deprecated: Use NewFunction instead. OldFunction will be removed in v2.0.
func OldFunction() {
    // old implementation
}

// NewFunction does something in the new, improved way.
// It replaces OldFunction with better performance and cleaner API.
func NewFunction() {
    // new implementation
}

// Package myapi provides a RESTful API server.
//
// # Version History
//
// v1.2.0 (2024-01-15)
//   - Added support for pagination
//   - Improved error messages
//   - Fixed memory leak in connection pool
//
// v1.1.0 (2023-12-01)
//   - Added user authentication
//   - New endpoint for bulk operations
//
// v1.0.0 (2023-10-01)
//   - Initial release
//
package myapi

# .github/workflows/docs.yml
name: Generate Documentation

on:
  push:
    branches: [ main ]

jobs:
  docs:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Go
      uses: actions/setup-go@v4
      with:
        go-version: '1.21'
    
    - name: Install godoc
      run: go install golang.org/x/tools/cmd/godoc@latest
    
    - name: Generate documentation
      run: |
        godoc -html=mypackage > docs/index.html
    
    - name: Deploy to GitHub Pages
      uses: peaceiris/actions-gh-pages@v3
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
        publish_dir: ./docs

# Makefile
.PHONY: docs docs-serve docs-open

# 문서 HTML 생성
docs:
	@echo "Generating documentation..."
	@godoc -html=./mypackage > docs/index.html
	@echo "Documentation generated in docs/index.html"

# 문서 서버 시작
docs-serve:
	@echo "Starting documentation server on http://localhost:6060"
	@godoc -http=:6060

# 문서 서버 시작하고 브라우저 열기
docs-open:
	@echo "Opening documentation in browser..."
	@(sleep 2 && open http://localhost:6060/pkg/mypackage) &
	@godoc -http=:6060

# 코드 검사 (문서 관련 경고 포함)
go vet ./...

# 더 상세한 검사
go vet -v ./...

# golint 설치
go install golang.org/x/lint/golint@latest

# 전체 프로젝트 검사
golint ./...

# 특정 패키지만 검사
golint ./handlers

# golangci-lint 설치
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# 실행
golangci-lint run

# 특정 린터만 실행
golangci-lint run --enable=godot,godox

// ❌ 나쁜 예: 구현 세부사항에 집중
// Connect establishes a TCP connection using net.Dial
// and stores the connection in the internal conn field.

// ✅ 좋은 예: 사용법에 집중
// Connect establishes a connection to the database.
// It returns an error if the connection fails or times out.
// The connection is automatically retried up to 3 times.

// ❌ 너무 단순한 예제
// Example:
//     result := Add(1, 2)

// ✅ 현실적인 예제
// Example:
//     // 사용자 입력 처리
//     input1, _ := strconv.Atoi(os.Args[1])
//     input2, _ := strconv.Atoi(os.Args[2])
//     
//     result := Add(input1, input2)
//     fmt.Printf("Result: %d\n", result)

// ReadConfig reads and parses the configuration file.
//
// It returns the following errors:
//   - ErrFileNotFound: if the config file doesn't exist
//   - ErrInvalidFormat: if the file is not valid YAML
//   - ErrPermissionDenied: if the file cannot be read
//
// Example:
//
//     config, err := ReadConfig("config.yaml")
//     if errors.Is(err, ErrFileNotFound) {
//         // handle missing file
//     }
func ReadConfig(path string) (*Config, error) {
    // implementation
}

// Sort sorts the slice in ascending order.
// It uses quicksort algorithm with O(n log n) average time complexity.
// The sort is not stable and modifies the slice in-place.
//
// For stable sorting, use StableSort instead.
func Sort(data []int) {
    // implementation
}

// Cache provides an in-memory cache with expiration support.
// All methods are safe for concurrent use by multiple goroutines.
type Cache struct {
    mu    sync.RWMutex
    items map[string]*item
}

// Set adds or updates a value in the cache.
// This method is safe for concurrent use.
func (c *Cache) Set(key string, value interface{}) {
    // implementation
}

// Package taskqueue provides a simple, thread-safe task queue
// with priority support and worker pool management.
//
// # Overview
//
// This package implements a priority-based task queue that allows
// you to submit tasks and process them asynchronously using a pool
// of worker goroutines. Tasks are executed in priority order, with
// higher priority tasks being processed first.
//
// # Features
//
//   - Thread-safe operations
//   - Priority-based task scheduling
//   - Configurable worker pool size
//   - Graceful shutdown support
//   - Task timeout handling
//   - Comprehensive error reporting
//
// # Quick Start
//
// Create a new queue and start processing tasks:
//
//     queue := taskqueue.New(taskqueue.Config{
//         Workers: 5,
//         BufferSize: 100,
//     })
//     
//     queue.Start()
//     defer queue.Stop()
//     
//     // Submit a task
//     err := queue.Submit(taskqueue.Task{
//         ID: "task-1",
//         Priority: taskqueue.PriorityHigh,
//         Handler: func(ctx context.Context) error {
//             // Your task logic here
//             return nil
//         },
//     })
//
// # Architecture
//
// The queue consists of three main components:
//
//   1. Queue: Manages task submission and distribution
//   2. Worker Pool: Executes tasks concurrently
//   3. Priority Heap: Maintains task ordering
//
// # Performance Considerations
//
// The queue uses a heap-based priority queue with O(log n) insertion
// and removal. Worker goroutines are pre-allocated and reused for
// efficiency. Memory usage scales with the buffer size and number
// of pending tasks.
//
// # Thread Safety
//
// All public methods are safe for concurrent use. Internal
// synchronization is handled using mutexes and channels.
//
package taskqueue

import (
    "context"
    "errors"
    "sync"
    "time"
)

// Priority represents the priority level of a task.
// Higher values indicate higher priority.
type Priority int

const (
    // PriorityLow is for non-urgent background tasks.
    PriorityLow Priority = 1
    
    // PriorityNormal is the default priority for regular tasks.
    PriorityNormal Priority = 5
    
    // PriorityHigh is for urgent tasks that should be processed quickly.
    PriorityHigh Priority = 10
    
    // PriorityCritical is for critical tasks that must be processed immediately.
    PriorityCritical Priority = 100
)

// Task represents a unit of work to be executed by the queue.
// Tasks are executed asynchronously by worker goroutines.
type Task struct {
    // ID is a unique identifier for the task.
    // It's used for tracking and logging purposes.
    ID string
    
    // Priority determines the execution order.
    // Tasks with higher priority are executed first.
    Priority Priority
    
    // Handler is the function that performs the actual work.
    // It receives a context that may be cancelled if the task times out.
    Handler func(context.Context) error
    
    // Timeout specifies the maximum duration for task execution.
    // Zero means no timeout. Default is 30 seconds.
    Timeout time.Duration
    
    // Retries specifies the number of retry attempts on failure.
    // Zero means no retries. Default is 0.
    Retries int
}

// Config holds configuration options for the queue.
type Config struct {
    // Workers is the number of worker goroutines.
    // Default is the number of CPU cores.
    Workers int
    
    // BufferSize is the capacity of the internal task buffer.
    // Larger values allow more tasks to be queued but use more memory.
    // Default is 100.
    BufferSize int
    
    // DefaultTimeout is the default timeout for tasks without a specific timeout.
    // Default is 30 seconds.
    DefaultTimeout time.Duration
    
    // ShutdownTimeout is the maximum time to wait for tasks to complete during shutdown.
    // Default is 10 seconds.
    ShutdownTimeout time.Duration
}

// Queue manages task submission and execution.
// It maintains a pool of worker goroutines that process tasks concurrently.
//
// All methods are safe for concurrent use by multiple goroutines.
type Queue struct {
    config  Config
    tasks   chan Task
    workers []*worker
    wg      sync.WaitGroup
    mu      sync.RWMutex
    running bool
}

// New creates a new Queue with the given configuration.
// If config is nil, default values are used.
//
// The queue is created in a stopped state. Call Start to begin processing tasks.
func New(config Config) *Queue {
    // Set defaults
    if config.Workers <= 0 {
        config.Workers = runtime.NumCPU()
    }
    if config.BufferSize <= 0 {
        config.BufferSize = 100
    }
    if config.DefaultTimeout == 0 {
        config.DefaultTimeout = 30 * time.Second
    }
    if config.ShutdownTimeout == 0 {
        config.ShutdownTimeout = 10 * time.Second
    }
    
    return &Queue{
        config: config,
        tasks:  make(chan Task, config.BufferSize),
    }
}

// Start begins processing tasks.
// It spawns worker goroutines according to the configuration.
//
// This method is idempotent - calling it multiple times has no effect
// if the queue is already running.
//
// Returns an error if the queue is already stopped and cannot be restarted.
func (q *Queue) Start() error {
    q.mu.Lock()
    defer q.mu.Unlock()
    
    if q.running {
        return nil
    }
    
    // Start workers
    q.workers = make([]*worker, q.config.Workers)
    for i := 0; i < q.config.Workers; i++ {
        w := &worker{
            id:    i,
            tasks: q.tasks,
        }
        q.workers[i] = w
        q.wg.Add(1)
        go w.run(&q.wg)
    }
    
    q.running = true
    return nil
}

// Submit adds a task to the queue for processing.
// The task will be executed by an available worker goroutine.
//
// If the task buffer is full, this method blocks until space becomes available
// or the context is cancelled.
//
// Returns an error if:
//   - The queue is not running
//   - The task ID is empty
//   - The task handler is nil
//   - The context is cancelled
func (q *Queue) Submit(task Task) error {
    q.mu.RLock()
    defer q.mu.RUnlock()
    
    if !q.running {
        return errors.New("queue is not running")
    }
    
    if task.ID == "" {
        return errors.New("task ID cannot be empty")
    }
    
    if task.Handler == nil {
        return errors.New("task handler cannot be nil")
    }
    
    // Set default timeout if not specified
    if task.Timeout == 0 {
        task.Timeout = q.config.DefaultTimeout
    }
    
    select {
    case q.tasks <- task:
        return nil
    default:
        return errors.New("queue is full")
    }
}

// Stop gracefully shuts down the queue.
// It waits for all currently executing tasks to complete,
// up to the configured shutdown timeout.
//
// Tasks that are queued but not yet started will not be executed.
// This method blocks until all workers have stopped or the timeout expires.
//
// After calling Stop, the queue cannot be restarted.
func (q *Queue) Stop() error {
    q.mu.Lock()
    if !q.running {
        q.mu.Unlock()
        return nil
    }
    q.running = false
    close(q.tasks)
    q.mu.Unlock()
    
    // Wait for workers with timeout
    done := make(chan struct{})
    go func() {
        q.wg.Wait()
        close(done)
    }()
    
    select {
    case <-done:
        return nil
    case <-time.After(q.config.ShutdownTimeout):
        return errors.New("shutdown timeout exceeded")
    }
}

// Stats returns current queue statistics.
// This method is safe for concurrent use.
func (q *Queue) Stats() Stats {
    q.mu.RLock()
    defer q.mu.RUnlock()
    
    return Stats{
        Workers:     q.config.Workers,
        QueuedTasks: len(q.tasks),
        Running:     q.running,
    }
}

// Stats contains queue statistics.
type Stats struct {
    // Workers is the number of worker goroutines.
    Workers int
    
    // QueuedTasks is the number of tasks waiting to be processed.
    QueuedTasks int
    
    // Running indicates whether the queue is currently processing tasks.
    Running bool
}

// taskqueue_test.go
package taskqueue_test

import (
    "context"
    "fmt"
    "time"
    "yourmodule/taskqueue"
)

// ExampleQueue demonstrates basic queue usage.
func ExampleQueue() {
    // Create and start queue
    queue := taskqueue.New(taskqueue.Config{
        Workers: 2,
        BufferSize: 10,
    })
    
    queue.Start()
    defer queue.Stop()
    
    // Submit a simple task
    err := queue.Submit(taskqueue.Task{
        ID: "example-task",
        Priority: taskqueue.PriorityNormal,
        Handler: func(ctx context.Context) error {
            fmt.Println("Task executed!")
            return nil
        },
    })
    
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    // Wait a bit for task to complete
    time.Sleep(100 * time.Millisecond)
    
    // Output: Task executed!
}

// ExampleQueue_priority demonstrates priority-based execution.
func ExampleQueue_priority() {
    queue := taskqueue.New(taskqueue.Config{
        Workers: 1, // Single worker to see priority effect
        BufferSize: 10,
    })
    
    queue.Start()
    defer queue.Stop()
    
    // Submit tasks with different priorities
    tasks := []struct {
        id       string
        priority taskqueue.Priority
    }{
        {"low", taskqueue.PriorityLow},
        {"high", taskqueue.PriorityHigh},
        {"normal", taskqueue.PriorityNormal},
        {"critical", taskqueue.PriorityCritical},
    }
    
    for _, t := range tasks {
        queue.Submit(taskqueue.Task{
            ID: t.id,
            Priority: t.priority,
            Handler: func(ctx context.Context) error {
                fmt.Printf("Executing: %s\n", t.id)
                return nil
            },
        })
    }
    
    time.Sleep(500 * time.Millisecond)
    
    // Output:
    // Executing: critical
    // Executing: high
    // Executing: normal
    // Executing: low
}

// ExampleQueue_timeout demonstrates task timeout handling.
func ExampleQueue_timeout() {
    queue := taskqueue.New(taskqueue.Config{
        Workers: 1,
    })
    
    queue.Start()
    defer queue.Stop()
    
    // Submit a task with short timeout
    queue.Submit(taskqueue.Task{
        ID: "timeout-task",
        Timeout: 100 * time.Millisecond,
        Handler: func(ctx context.Context) error {
            select {
            case <-time.After(1 * time.Second):
                return nil
            case <-ctx.Done():
                fmt.Println("Task cancelled due to timeout")
                return ctx.Err()
            }
        },
    })
    
    time.Sleep(200 * time.Millisecond)
    
    // Output: Task cancelled due to timeout
}

# CONTRIBUTING.md

## 문서화 가이드라인

### 필수 사항
- 모든 공개 함수/타입에 주석 작성
- 주석은 선언 이름으로 시작
- 완전한 문장으로 작성 (마침표 포함)
- 에러 조건 명시

### 권장 사항
- 복잡한 로직에는 예제 코드 추가
- 성능 특성 문서화
- 스레드 안전성 명시

### 코드 리뷰 체크리스트
- [ ] 모든 공개 API에 주석이 있는가?
- [ ] 주석이 올바른 형식인가?
- [ ] 예제 코드가 동작하는가?
- [ ] golint 경고가 없는가?

## PR 체크리스트
- [ ] 코드 변경사항 구현
- [ ] 테스트 작성/업데이트
- [ ] 문서 업데이트
- [ ] CHANGELOG 업데이트
- [ ] 예제 코드 검증

# .github/workflows/docs-check.yml
name: Documentation Check

on: [pull_request]

jobs:
  docs:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - uses: actions/setup-go@v4
      with:
        go-version: '1.21'
    
    - name: Check documentation
      run: |
        go install golang.org/x/lint/golint@latest
        golint -set_exit_status ./...
    
    - name: Verify examples
      run: |
        go test -run Example

// 공개 API - 상세한 문서
// ProcessData processes the input data according to the specified rules.
// It validates the input, applies transformations, and returns the result.
//
// The function supports multiple data formats including JSON and XML.
// Invalid input returns ErrInvalidFormat.
//
// Example:
//     result, err := ProcessData(input, rules)
func ProcessData(input []byte, rules Rules) ([]byte, error) {
    // ...
}

// 내부 함수 - 간단한 설명
// validateInput checks if the input data is valid.
// Returns error if validation fails.
func validateInput(input []byte) error {
    // ...
}

// FindShortestPath finds the shortest path between two nodes using Dijkstra's algorithm.
//
// # Algorithm
//
// The function implements Dijkstra's shortest path algorithm:
//   1. Initialize distances to all nodes as infinite except start node (0)
//   2. Create a priority queue with the start node
//   3. While queue is not empty:
//      - Extract node with minimum distance
//      - For each neighbor, calculate tentative distance
//      - Update distance if shorter path found
//   4. Return the path and total distance
//
// # Complexity
//
// Time: O((V + E) log V) where V is vertices and E is edges
// Space: O(V) for the distance map and priority queue
//
// # Example
//
//     graph := NewGraph()
//     graph.AddEdge("A", "B", 5)
//     graph.AddEdge("B", "C", 3)
//     
//     path, distance := FindShortestPath(graph, "A", "C")
//     // path: ["A", "B", "C"], distance: 8
//
func FindShortestPath(graph *Graph, start, end string) ([]string, int, error) {
    // implementation
}