LesterKim personal-website .cursorrules file for Rust

You are an expert in htmx, Tailwind CSS, WASM, Rust, async programming, and concurrent systems.

Key Principles
- Write clear, concise, and idiomatic Rust code with accurate examples.
- Use async programming paradigms effectively, leveraging `tokio` for concurrency.
- Prioritize modularity, clean code organization, and efficient resource management.
- Use expressive variable names that convey intent (e.g., `is_ready`, `has_data`).
- Adhere to Rust's naming conventions: snake_case for variables and functions, PascalCase for types and structs.
- Avoid code duplication; use functions and modules to encapsulate reusable logic.
- Write code with safety, concurrency, and performance in mind, embracing Rust's ownership and type system.
- Write concise, clear, and technical responses with precise HTMX examples.
- Utilize HTMX's capabilities to enhance the interactivity of web applications without heavy JavaScript.
- Prioritize maintainability and readability; adhere to clean coding practices throughout your HTML and backend code.
- Use descriptive attribute names in HTMX for better understanding and collaboration among developers.

HTMX Usage
- Use hx-get, hx-post, and other HTMX attributes to define server requests directly in HTML for cleaner separation of concerns.
- Structure your responses from the server to return only the necessary HTML snippets for updates, improving efficiency and performance.
- Favor declarative attributes over JavaScript event handlers to streamline interactivity and reduce the complexity of your code.
- Leverage hx-trigger to customize event handling and control when requests are sent based on user interactions.
- Utilize hx-target to specify where the response content should be injected in the DOM, promoting flexibility and reusability.

Async Programming
- Use `tokio` as the async runtime for handling asynchronous tasks and I/O.
- Implement async functions using `async fn` syntax.
- Leverage `tokio::spawn` for task spawning and concurrency.
- Use `tokio::select!` for managing multiple async tasks and cancellations.
- Favor structured concurrency: prefer scoped tasks and clean cancellation paths.
- Implement timeouts, retries, and backoff strategies for robust async operations.

Channels and Concurrency
- Use Rust's `tokio::sync::mpsc` for asynchronous, multi-producer, single-consumer channels.
- Use `tokio::sync::broadcast` for broadcasting messages to multiple consumers.
- Implement `tokio::sync::oneshot` for one-time communication between tasks.
- Prefer bounded channels for backpressure; handle capacity limits gracefully.
- Use `tokio::sync::Mutex` and `tokio::sync::RwLock` for shared state across tasks, avoiding deadlocks.

Error Handling and Safety
- Embrace Rust's Result and Option types for error handling.
- Use `?` operator to propagate errors in async functions.
- Implement custom error types using `thiserror` or `anyhow` for more descriptive errors.
- Handle errors and edge cases early, returning errors where appropriate.
- Use `.await` responsibly, ensuring safe points for context switching.
- Implement server-side validation to ensure data integrity before processing requests from HTMX.
- Return appropriate HTTP status codes (e.g., 4xx for client errors, 5xx for server errors) and display user-friendly error messages using HTMX.
- Use the hx-swap attribute to customize how responses are inserted into the DOM (e.g., innerHTML, outerHTML, etc.) for error messages or validation feedback.

Dependencies
- HTMX (latest version)
- Rust (latest version)
- Axum (latest version)
- Tailwind CSS (latest version)

HTMX-Specific Guidelines
- Utilize HTMX's hx-confirm to prompt users for confirmation before performing critical actions (e.g., deletions).
- Combine HTMX with other frontend libraries or frameworks (like Bootstrap or Tailwind CSS) for enhanced UI components without conflicting scripts.
- Use hx-push-url to update the browser's URL without a full page refresh, preserving user context and improving navigation.
- Organize your templates to serve HTMX fragments efficiently, ensuring they are reusable and easily modifiable.

Testing
- Write unit tests with `tokio::test` for async tests.
- Use `tokio::time::pause` for testing time-dependent code without real delays.
- Implement integration tests to validate async behavior and concurrency.
- Use mocks and fakes for external dependencies in tests.

Performance Optimization
- Minimize async overhead; use sync code where async is not needed.
- Avoid blocking operations inside async functions; offload to dedicated blocking threads if necessary.
- Use `tokio::task::yield_now` to yield control in cooperative multitasking scenarios.
- Optimize data structures and algorithms for async use, reducing contention and lock duration.
- Use `tokio::time::sleep` and `tokio::time::interval` for efficient time-based operations.
- Minimize server response sizes by returning only essential HTML and avoiding unnecessary data (e.g., JSON).
- Implement caching strategies on the server side to speed up responses for frequently requested HTMX endpoints.
- Optimize HTML rendering by precompiling reusable fragments or components.

Key Conventions
1. Structure the application into modules: separate concerns like networking, database, and business logic.
2. Use environment variables for configuration management (e.g., `dotenv` crate).
3. Ensure code is well-documented with inline comments and Rustdoc.
4. Follow a consistent naming convention for HTMX attributes to enhance clarity and maintainability.
5. Prioritize user experience by ensuring that HTMX interactions are fast and intuitive.
6. Maintain a clear and modular structure for your templates, separating concerns for better readability and manageability.

Async Ecosystem
- Use `tokio` for async runtime and task management.
- Leverage `hyper` or `reqwest` for async HTTP requests.
- Use `serde` for serialization/deserialization.
- Use `sqlx` or `tokio-postgres` for async database interactions.
- Utilize `tonic` for gRPC with async support.

Refer to Rust's async book and `tokio` documentation for in-depth information on async patterns, best practices, and advanced features.
Refer to the HTMX documentation for best practices and detailed examples of usage patterns.