Browse

tokio::time::interval .cursorrules prompt files

`tokio::time::interval` is an asynchronous timer in the Tokio library that produces periodic events at fixed intervals, ideal for tasks requiring consistent repetition without blocking execution.

Filters

All

React

Tailwind CSS

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

JavaScript

Shadcn UI

Next.js

Radix UI

Python

WebP

Zod

JSX

Vite

CSS

Supabase

HTML

Jest

Next.js App Router

PostgreSQL

Docker

Redis

Pydantic

Tailwind Aria

TailwindCSS

FastAPI

Git

ESLint

pytest

react-hook-form

Solidity

Vercel

JSDoc

GitHub Actions

Typescript

Prettier

Suspense

Vitest

ARIA

Zustand

React Testing Library

Celery

Radix

Shadcn

SQLAlchemy

PHP

SvelteKit

JSON

Vue.js

Pinia

MongoDB

tRPC

Clerk

Expo

PEP 8

SSR

Prisma

dotenv

GitLab CI

SQLite

SQL

Playwright

tanStackQuery

DaisyUI

Laravel

RESTful API

Drizzle ORM

VueUse

Express

asyncpg

TypeScript

scikit-learn

pandas

GitHub

RabbitMQ

Rust

Java

GraphQL

Svelte

Elixir

ES6

Nuxt 3

styled-components

Vue Router

Astro

Svelte 5

Markdown

OpenZeppelin

Drizzle

Stripe

Flexbox

CORS

Lighthouse

JWT

Swagger

aiomysql

Ruff

Langchain

Django

matplotlib

Clear

Blockchain Development

Visualization

JavaScript Development

Refactoring

Development Workflow

Code Refactoring

Code Generation

Programming Patterns

Commit Messages

Clean Code Practices

Content Management

Styling

DevOps

Mobile-First Design

App Development

Form Handling

Cloud Computing

Serverless Architecture

Microservices

Next.js

Vue.js

Automation

React Best Practices

Ethereum

Game Design

Semantic HTML

Structure

Python Libraries

dependency management

documentation

modular programming

software architecture

AI Programming

RESTful API Design

Testing and Deployment

Machine Learning

Data Science

Jupyter Notebook

Maintainable Code

Logging and Monitoring

Software Architecture

TypeScript Interfaces

Front-end Development

Database

Cryptography

Continuous Integration

Component Development

Cross-browser Compatibility

Dependency Management.

SOLID Principles

Simulation

User Interaction

User Interface Design

UI/UX Design

Modularity

Windows Compatibility

Continuous Improvement

Error Handling.

Component Architecture

Software Development Best Practices

User Authentication

Pseudocode

Programming Standards

Database Querying

Components

Open Source

AI Programming Assistant

Gas Optimization

Product Management

Technical Documentation

Containerization

Collaboration

Syntax

Asynchronous Programming

Payment Integration

AI Integration

Frontend Frameworks

ORM

Deployment Strategies

API Documentation

User Experience

Maintainability

Application Architecture

Integration

Environment variables

SDK Development

React Components

Programming Concepts

UI Styling

Unit Testing

Code Testing

Dart Programming

Development

Game Programming

AI Development

HTML

Authentication and Authorization

Data Integrity

Media Queries

Reactive Programming

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Rust Tokio Async Programming .cursorrules prompt file

You are an expert in 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.

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.

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.

Key Conventions

Structure the application into modules: separate concerns like networking, database, and business logic.
Use environment variables for configuration management (e.g., dotenv crate).
Ensure code is well-documented with inline comments and Rustdoc.

Async Ecosystem