documentation

/// Processes the input data according to the specified configuration.
///
/// This function validates the input, applies transformations, and returns
/// the processed result. It handles both streaming and batch inputs.
///
/// # Arguments
///
/// * `input` - The data to process, must not be empty
/// * `config` - Processing configuration options
///
/// # Returns
///
/// The processed data wrapped in `Result`. Returns an error if:
/// - Input is empty
/// - Configuration is invalid
/// - Processing fails due to resource constraints
///
/// # Errors
///
/// Returns [`ProcessError::EmptyInput`] if the input slice is empty.
/// Returns [`ProcessError::InvalidConfig`] if configuration validation fails.
///
/// # Examples
///
/// Basic usage:
///
/// ```rust
/// use my_crate::{process, Config};
///
/// let input = vec![1, 2, 3];
/// let config = Config::default();
/// let result = process(&input, &config)?;
/// assert_eq!(result.len(), 3);
/// # Ok::<(), my_crate::ProcessError>(())
/// ```
///
/// With custom configuration:
///
/// ```rust
/// use my_crate::{process, Config};
///
/// let config = Config::builder()
///     .batch_size(100)
///     .timeout(Duration::from_secs(30))
///     .build();
///
/// let result = process(&large_input, &config)?;
/// # Ok::<(), my_crate::ProcessError>(())
/// ```
///
/// # Panics
///
/// This function does not panic under normal conditions.
///
/// # Performance
///
/// This operation is O(n) where n is the input length.
/// For inputs larger than 10,000 elements, consider using
/// [`process_streaming`] for better memory efficiency.
pub fn process(input: &[u8], config: &Config) -> Result<Vec<u8>, ProcessError> {
    // ...
}

# Project Name

Brief description (1-2 sentences) of what this project does.

[![Crates.io](https://img.shields.io/crates/v/project-name.svg)](https://crates.io/crates/project-name)
[![Documentation](https://docs.rs/project-name/badge.svg)](https://docs.rs/project-name)
[![License](https://img.shields.io/crates/l/project-name.svg)](LICENSE)

## Features

- Feature 1: Brief description
- Feature 2: Brief description
- Feature 3: Brief description

## Installation

```toml
[dependencies]
project-name = "0.1"

use project_name::Client;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let result = client.do_something()?;
    println!("{}", result);
    Ok(())
}

### 3. Module Documentation
```rust
//! # Module Name
//!
//! Brief description of what this module provides.
//!
//! ## Overview
//!
//! Longer explanation of the module's purpose and how it fits
//! into the larger system.
//!
//! ## Usage
//!
//! ```rust
//! use crate::module_name::Feature;
//!
//! let feature = Feature::new();
//! feature.do_thing();
//! ```
//!
//! ## Architecture
//!
//! Explanation of key types and their relationships.
//!
//! ## See Also
//!
//! - [`related_module`] - For related functionality
//! - [`other_type`] - For alternative approach

# Contributing to Project Name

## Getting Started

1. Fork the repository
2. Clone your fork: `git clone https://github.com/you/project.git`
3. Create a branch: `git checkout -b feature/your-feature`

## Development Setup

```bash
# Install Rust (if needed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Build the project
cargo build

# Run tests
cargo test

# Run lints
cargo clippy

## Documentation Standards

### Token Limits (Conciseness)
| Type | Maximum |
|------|---------|
| Function doc summary | 1 line |
| Module doc overview | 3-5 lines |
| README description | 2 sentences |
| Example code | 10 lines |

### Required Sections
- **Public functions**: Summary, Arguments, Returns, Errors, Examples
- **Public types**: Summary, Fields (for structs), Variants (for enums)
- **Modules**: Overview, Usage example, Key types

### Documentation Testing
```bash
# Test documentation examples
cargo test --doc

# Generate and check docs
cargo doc --no-deps

# Check for broken links
cargo doc --no-deps 2>&1 | grep "warning"