ownership-borrowing

pluginagentmarketplace's avatarfrom pluginagentmarketplace

Master Rust's ownership, borrowing, and lifetime system

⭐1stars🔀0forks📁View on GitHub🕐Updated Jan 5, 2026
[Tutoring and Explanations]

When & Why to Use This Skill

This Claude skill provides a comprehensive guide to mastering Rust's core memory safety features, including ownership rules, borrowing mechanics, and lifetime annotations. It helps developers understand how Rust manages memory without a garbage collector, ensuring high performance and thread safety through clear explanations and practical code examples.

Use Cases

  • Understanding the three rules of ownership to prevent memory leaks and manage data lifecycle effectively.
  • Implementing immutable and mutable borrowing to manage data access safely across different scopes and functions.
  • Resolving common 'borrow checker' compiler errors such as 'value borrowed after move' or 'cannot borrow as mutable'.
  • Applying explicit lifetime annotations to functions and structs to handle complex data references and ensure memory safety.
nameownership-borrowing
descriptionMaster Rust's ownership, borrowing, and lifetime system
sasmp_version"1.3.0"
bonded_agentrust-fundamentals-agent
bond_typePRIMARY_BOND
version"1.0.0"

Ownership & Borrowing Skill

Master Rust's revolutionary memory safety system without garbage collection.

Quick Start

The Three Rules of Ownership

// Rule 1: Each value has exactly ONE owner
let s1 = String::from("hello");  // s1 owns this String

// Rule 2: Only ONE owner at a time
let s2 = s1;  // Ownership MOVES to s2
// println!("{}", s1);  // ERROR: s1 no longer valid

// Rule 3: Value is dropped when owner goes out of scope
{
    let s3 = String::from("temporary");
}  // s3 dropped here, memory freed

Borrowing Basics

fn main() {
    let s = String::from("hello");

    // Immutable borrow
    let len = calculate_length(&s);
    println!("{} has length {}", s, len);

    // Mutable borrow
    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);  // "hello, world"
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change(s: &mut String) {
    s.push_str(", world");
}

Lifetime Annotations

// Explicit lifetime annotation
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

// Struct with lifetime
struct Excerpt<'a> {
    part: &'a str,
}

Common Patterns

Pattern 1: Clone When Needed

let s1 = String::from("hello");
let s2 = s1.clone();  // Deep copy
println!("{} {}", s1, s2);  // Both valid

Pattern 2: Return Ownership

fn process(s: String) -> String {
    // Do something with s
    s  // Return ownership
}

Pattern 3: Borrow for Read-Only

fn analyze(data: &Vec<i32>) -> Summary {
    // Only read, don't own
    Summary::from(data)
}

Error Solutions

"value borrowed after move"

// Problem
let s = String::from("hello");
let s2 = s;
println!("{}", s);  // ERROR

// Solution 1: Clone
let s2 = s.clone();

// Solution 2: Borrow
let s2 = &s;

"cannot borrow as mutable"

// Problem
let s = String::from("hello");
change(&mut s);  // ERROR: s is not mut

// Solution: Declare as mutable
let mut s = String::from("hello");
change(&mut s);  // OK

Resources