菜单
Rust 不稳定特性技能。提供 Rust 不稳定特性的完整参考，包括 nightly 特性、实验性功能等。TRIGGER when: 用户使用 nightly Rust、需要不稳定特性、或需要了解实验性功能时触发。SKIP: 稳定版 Rust 开发。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
基于 SOC 职业分类
Rust 高级特性技能。提供 Rust 高级特性的完整参考，包括 unsafe Rust、高级 trait、高级类型、宏、FFI 等。TRIGGER when: 用户使用 unsafe 代码、实现高级 trait、使用高级类型、编写宏、或需要了解 Rust 高级特性时触发。SKIP: 基础 Rust 开发。
Rust CLI 工具开发技能。提供使用 Rust 开发命令行工具的完整参考，包括参数解析、错误处理、输出格式化、跨平台支持等。TRIGGER when: 用户开发 Rust CLI 工具、使用 clap/structopt、处理命令行参数、格式化输出、或需要了解 Rust CLI 最佳实践时触发。SKIP: 非 CLI 工具的 Rust 开发。
Rust 版本指南技能。提供 Rust 版本（Edition）的完整参考，包括版本差异、迁移指南、新特性等。TRIGGER when: 用户需要了解 Rust 版本差异、迁移代码到新版本、或需要了解版本新特性时触发。SKIP: 非版本相关的 Rust 开发。
Rust 嵌入式开发技能。提供使用 Rust 进行嵌入式开发的完整参考，包括 no_std 环境、HAL 层、外设驱动、中断处理、实时系统等。TRIGGER when: 用户开发嵌入式 Rust 程序、使用 cortex-m/esp-hal、配置 no_std 环境、处理硬件外设、或需要了解 Rust 嵌入式最佳实践时触发。SKIP: 非嵌入式 Rust 开发。
Rust 练习技能。提供 Rust 练习和学习资源的完整参考，包括 Rustlings、练习题、最佳实践等。TRIGGER when: 用户学习 Rust、需要练习题、或需要了解 Rust 学习资源时触发。SKIP: 非学习相关的 Rust 开发。
Rust 语言核心开发技能。提供 Rust 语言的完整参考，包括所有权、借用、生命周期、泛型、trait、错误处理、并发、异步等核心概念。TRIGGER when: 用户编写 Rust 代码、询问 Rust 语法、需要 Rust 代码示例、调试 Rust 程序、或需要了解 Rust 语言特性时触发。SKIP: 非 Rust 语言的开发任务。
| name | rust-unstable |
| description | Rust 不稳定特性技能。提供 Rust 不稳定特性的完整参考，包括 nightly 特性、实验性功能等。TRIGGER when: 用户使用 nightly Rust、需要不稳定特性、或需要了解实验性功能时触发。SKIP: 稳定版 Rust 开发。 |
本技能提供 Rust 不稳定特性的完整参考，基于 Unstable Book。
当用户执行以下操作时触发此技能：
以下情况不触发此技能：
rustup install nightly
rustup default nightly
#![feature(some_feature)]
fn main() {
// 使用不稳定特性
}
#![feature(async_fn_in_trait)]
trait Database {
async fn get(&self, key: &str) -> Option<String>;
async fn set(&self, key: &str, value: String);
}
struct MyDatabase;
impl Database for MyDatabase {
async fn get(&self, key: &str) -> Option<String> {
// 实现
None
}
async fn set(&self, key: &str, value: String) {
// 实现
}
}
#![feature(generic_const_exprs)]
struct Array<T, const N: usize> {
data: [T; N],
}
impl<T, const N: usize> Array<T, N> {
fn len(&self) -> usize {
N
}
}
fn main() {
let arr = Array { data: [1, 2, 3] };
println!("长度: {}", arr.len());
}
#![feature(type_alias_impl_trait)]
type MyFuture = impl std::future::Future<Output = i32>;
fn make_future() -> MyFuture {
async { 42 }
}
fn main() {
let future = make_future();
}
#![feature(generators, generator_trait)]
use std::ops::{Generator, GeneratorState};
fn main() {
let mut generator = || {
yield 1;
yield 2;
yield 3;
return "done";
};
loop {
match generator.resume() {
GeneratorState::Yielded(value) => println!("Yielded: {}", value),
GeneratorState::Complete(result) => {
println!("Complete: {}", result);
break;
}
}
}
}
#![feature(box_syntax)]
fn main() {
let boxed = box 42;
println!("{}", boxed);
}
#![feature(try_trait_v2)]
use std::ops::ControlFlow;
fn divide(a: i32, b: i32) -> ControlFlow<String, i32> {
if b == 0 {
ControlFlow::Break("除以零".to_string())
} else {
ControlFlow::Continue(a / b)
}
}
fn main() {
match divide(10, 2) {
ControlFlow::Continue(value) => println!("结果: {}", value),
ControlFlow::Break(error) => println!("错误: {}", error),
}
}
#![feature(pattern)]
use std::str::Pattern;
fn main() {
let s = "hello world";
let pattern = "world";
if let Some(index) = s.find(pattern) {
println!("找到 'world' 在索引 {}", index);
}
}
#![feature(slice_patterns)]
fn main() {
let v = vec![1, 2, 3, 4, 5];
match v.as_slice() {
[1, rest @ ..] => println!("以 1 开头, 剩余: {:?}", rest),
[.., 5] => println!("以 5 结尾"),
[first, middle @ .., last] => {
println!("第一个: {}, 中间: {:?}, 最后: {}", first, middle, last);
}
_ => println!("其他"),
}
}
#![feature(let_chains)]
fn main() {
let Some(x) = Some(42) else {
return;
};
if x > 0 && let Some(y) = Some(x * 2) {
println!("y = {}", y);
}
}
#![feature(generic_associated_types)]
trait LendingIterator {
type Item<'a> where Self: 'a;
fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}
struct WindowsMut<'a, T> {
slice: &'a mut [T],
pos: usize,
}
impl<'a, T> LendingIterator for WindowsMut<'a, T> {
type Item<'b> = &'b mut [T] where Self: 'b;
fn next<'b>(&'b mut self) -> Option<Self::Item<'b>> {
// 实现
None
}
}
#![feature(trait_upcasting)]
trait Animal {
fn name(&self) -> &str;
}
trait Dog: Animal {
fn bark(&self) -> &str;
}
struct MyDog;
impl Animal for MyDog {
fn name(&self) -> &str {
"MyDog"
}
}
impl Dog for MyDog {
fn bark(&self) -> &str {
"Woof!"
}
}
fn main() {
let dog: &dyn Dog = &MyDog;
let animal: &dyn Animal = dog; // trait upcasting
println!("{} says {}", animal.name(), dog.bark());
}