Skip to main content Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/diegosouzapw/awesome-omni-skill --skill moai-lang-rustO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Mais deste repositório Token-efficient tracking for AI orchestration. CLI-first for status updates (~50 tokens), agent fallback for complex ops (~1KB). Use when: updating task status, querying blockers, creating progress files, validating phases.
AshAi extension guidelines for integrating AI capabilities with Ash Framework. Use when implementing vectorization/embeddings, exposing Ash actions as LLM tools, creating prompt-backed actions, or setting up MCP servers. Covers semantic search, LangChain integration, and structured outputs.
This skill should be used when solving hard questions, complex architectural problems, or debugging issues that benefit from GPT-5 Pro or GPT-5.1 thinking models with large file context. Use when standard Claude analysis needs deeper reasoning or extended context windows.
Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
Explorador de arquivos
2 arquivos name moai-lang-rust description Rust 1.92+ development specialist covering Axum, Tokio, SQLx, and memory-safe systems programming. Use when building high-performance, memory-safe applications or WebAssembly. version 1.1.0 category language modularized false user-invocable false updated "2026-01-08T00:00:00.000Z" status active allowed-tools ["Read","Grep","Glob","mcp__context7__resolve-library-id","mcp__context7__get-library-docs"]
Quick Reference (30 seconds)
Rust 1.92+ Development Specialist with deep patterns for high-performance, memory-safe applications.
Auto-Triggers: .rs, Cargo.toml, async/await, Tokio, Axum, SQLx, serde, lifetimes, traits
Core Use Cases:
High-performance REST APIs and microservices
Memory-safe concurrent systems
CLI tools and system utilities
WebAssembly applications
Low-latency networking services
Quick Patterns:
Axum REST API:
let app = Router::new ()
.route ("/api/users/:id" , get (get_user))
.with_state (app_state);
let listener = tokio::net::TcpListener::bind ("0.0.0.0:3000" ).await ?;
axum::serve (listener, app).await ?;
Async Handler with SQLx:
async fn get_user (
State (state): State<AppState>,
Path (id): Path<i64 >,
) -> Result <Json<User>, AppError> {
let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1" , id)
.fetch_optional (&state.db).await ?
.ok_or (AppError::NotFound)?;
Ok (Json (user))
}
Implementation Guide (5 minutes)
Rust 1.92 Features
Modern Rust Features:
Rust 2024 Edition available (released with Rust 1.85)
Async traits in stable (no more async-trait crate needed)
Const generics for compile-time array sizing
let-else for pattern matching with early return
Improved borrow checker with polonius trait AsyncRepository {
async fn get (&self , id: i64 ) -> Result <User, Error>;
async fn create (&self , user: CreateUser) -> Result <User, Error>;
}
impl AsyncRepository for PostgresRepository {
async fn get (&self , id: i64 ) -> Result <User, Error> {
sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1" , id)
.fetch_one (&self .pool).await
}
}
fn get_user (id: Option <i64 >) -> Result <User, Error> {
let Some (id) = id else { return Err (Error::MissingId); };
let Ok (user) = repository.find (id) else { return Err (Error::NotFound); };
Ok (user)
}
Web Framework: Axum 0.8 [dependencies]
axum = "0.8"
tokio = { version = "1.48" , features = ["full" ] }
tower-http = { version = "0.6" , features = ["cors" , "trace" ] }
use axum::{extract::{Path, State, Query}, routing::{get, post}, Router, Json};
use tower_http::cors::CorsLayer;
#[derive(Clone)]
struct AppState { db: PgPool }
#[tokio::main]
async fn main () -> Result <(), Box <dyn std::error::Error>> {
let pool = PgPoolOptions::new ()
.max_connections (25 )
.connect (&std::env::var ("DATABASE_URL" )?).await ?;
let app = Router::new ()
.route ("/api/v1/users" , get (list_users).post (create_user))
.route ("/api/v1/users/:id" , get (get_user))
.layer (CorsLayer::permissive ())
.with_state (AppState { db: pool });
let listener = tokio::net::TcpListener::bind ("0.0.0.0:3000" ).await ?;
axum::serve (listener, app).await ?;
Ok (())
}
async fn list_users (
State (state): State<AppState>,
Query (params): Query<ListParams>,
) -> Result <Json<Vec <User>>, AppError> {
let users = sqlx::query_as!(User,
"SELECT * FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2" ,
params.limit.unwrap_or (10 ), params.offset.unwrap_or (0 ))
.fetch_all (&state.db).await ?;
Ok (Json (users))
}
Async Runtime: Tokio 1.48 Task Spawning and Channels:
use tokio::sync::mpsc;
async fn worker_pool () {
let (tx, mut rx) = mpsc::channel::<Job>(100 );
for _ in 0 ..4 {
tokio::spawn (async move {
while let Some (job) = rx.recv ().await { process_job (job).await ; }
});
}
}
async fn timeout_operation () -> Result <Data, Error> {
tokio::select! {
result = fetch_data () => result,
_ = tokio::time::sleep (Duration::from_secs (5 )) => Err (Error::Timeout),
}
}
Database: SQLx 0.8 #[derive(Debug, sqlx::FromRow)]
struct User { id: i64 , name: String , email: String }
async fn user_operations (pool: &PgPool) -> Result <(), sqlx::Error> {
let user = sqlx::query_as!(User,
"SELECT id, name, email FROM users WHERE id = $1" , 1i64 )
.fetch_one (pool).await ?;
let mut tx = pool.begin ().await ?;
sqlx::query!("INSERT INTO users (name, email) VALUES ($1, $2)" , "John" , "john@example.com" )
.execute (&mut *tx).await ?;
tx.commit ().await ?;
Ok (())
}
Serialization: Serde 1.0 use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase" )]
struct User {
id: i64 ,
#[serde(rename = "userName" )]
name: String ,
#[serde(skip_serializing_if = "Option::is_none" )]
profile_url: Option <String >,
#[serde(default)]
is_active: bool ,
}
Error Handling use thiserror::Error;
#[derive(Error, Debug)]
pub enum AppError {
#[error("database error: {0}" )]
Database (#[from] sqlx::Error),
#[error("not found: {0}" )]
NotFound (String ),
#[error("unauthorized" )]
Unauthorized,
}
impl IntoResponse for AppError {
fn into_response (self ) -> Response {
let (status, message) = match &self {
AppError::NotFound (_) => (StatusCode::NOT_FOUND, self .to_string ()),
AppError::Unauthorized => (StatusCode::UNAUTHORIZED, self .to_string ()),
AppError::Database (_) => (StatusCode::INTERNAL_SERVER_ERROR, "Internal error" .into ()),
};
(status, Json (json!({"error" : message}))).into_response ()
}
}
CLI Development: clap use clap::{Parser, Subcommand};
#[derive(Parser)]
#[command(name = "myapp" , version, about)]
struct Cli {
#[arg(short, long, global = true)]
config: Option <PathBuf>,
#[command(subcommand)]
command: Commands,
}
#[derive(Subcommand)]
enum Commands {
Serve { #[arg(short, long, default_value = "3000" )] port: u16 },
Migrate,
}
fn main () {
let cli = Cli::parse ();
match cli.command {
Commands::Serve { port } => serve (port),
Commands::Migrate => migrate (),
}
}
Testing Patterns #[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_create_user () {
let pool = setup_test_db ().await ;
let result = create_user (&pool, "John" , "john@example.com" ).await ;
assert! (result.is_ok ());
assert_eq! (result.unwrap ().name, "John" );
}
}
Advanced Patterns
Performance Optimization [profile.release]
lto = true
codegen-units = 1
panic = "abort"
strip = true
Deployment Minimal Container (5-15MB):
FROM rust:1.92-alpine AS builder
WORKDIR /app
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo "fn main(){}" > src/main.rs && cargo build --release
COPY src ./src
RUN touch src/main.rs && cargo build --release
FROM alpine:latest
COPY --from=builder /app/target/release/app /app
EXPOSE 3000
CMD ["/app"]
Concurrency use tokio::sync::Semaphore;
async fn rate_limited (items: Vec <String >, max: usize ) -> Vec <String > {
let sem = std::sync::Arc::new (Semaphore::new (max));
let handles : Vec <_> = items.into_iter ().map (|item| {
let sem = sem.clone ();
tokio::spawn (async move {
let _permit = sem.acquire ().await .unwrap ();
process_item (item).await
})
}).collect ();
futures::future::join_all (handles).await .into_iter ().filter_map (|r| r.ok ()).collect ()
}
Context7 Integration Library Documentation Access:
/rust-lang/rust - Rust language and stdlib/tokio-rs/tokio - Tokio async runtime/tokio-rs/axum - Axum web framework/launchbadge/sqlx - SQLx async SQL/serde-rs/serde - Serialization framework/dtolnay/thiserror - Error derive/clap-rs/clap - CLI parser
Works Well With
moai-lang-go - Go systems programming patternsmoai-domain-backend - REST API architecture and microservices patternsmoai-foundation-quality - Security hardening for Rust applicationsmoai-workflow-testing - Test-driven development workflows
Troubleshooting
Cargo errors: cargo clean && cargo build
Version check: rustc --version && cargo --version
Dependency issues: cargo update && cargo tree
Compile-time SQL check: cargo sqlx prepare
Performance Characteristics:
Startup Time: 50-100ms
Memory Usage: 5-20MB base
Throughput: 100k-200k req/s
Latency: p99 less than 5ms
Container Size: 5-15MB (alpine)
Additional Resources See reference.md for complete language reference and Context7 library mappings.
Last Updated: 2025-12-30
Version: 1.1.0
