メニュー
Rust 1.92+ development specialist covering Axum, Tokio, SQLx, and memory-safe systems programming. Use when building high-performance, memory-safe applications or WebAssembly.
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/diegosouzapw/awesome-omni-skill --skill moai-lang-rustコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
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.
SOC 職業分類に基づく
SKILL.md を表示中
| 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"] |
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:
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))
}
Modern Rust Features:
Async Traits (Stable):
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
}
}
Let-Else Pattern:
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)
}
Installation:
[dependencies]
axum = "0.8"
tokio = { version = "1.48", features = ["full"] }
tower-http = { version = "0.6", features = ["cors", "trace"] }
Complete API Setup:
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(())
}
Handler Patterns:
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))
}
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),
}
}
Type-Safe Queries:
#[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(())
}
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,
}
thiserror:
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()
}
}
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(),
}
}
#[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");
}
}
Release Build:
[profile.release]
lto = true
codegen-units = 1
panic = "abort"
strip = true
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"]
Rate-Limited Operations:
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()
}
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 parsermoai-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 workflowsCommon Issues:
cargo clean && cargo buildrustc --version && cargo --versioncargo update && cargo treecargo sqlx preparePerformance Characteristics:
See reference.md for complete language reference and Context7 library mappings.
See examples.md for production-ready code examples.
Last Updated: 2025-12-30 Version: 1.1.0