m14-mental-model

Name: m14-mental-model
Author: zhanghandong

Mental models and analogies for understanding Rust ownership, borrowing, and core concepts. Provides visual analogies (keys, lending, remotes) and mental models for ownership, moves, references, lifetimes, and smart pointers to build correct intuition Includes misconception-to-correction mappings for common borrow checker errors (E0382, E0502, E0499, E0106, E0507) with explanations of what safety guarantee each enforces Covers language-specific shifts for developers coming from Java, C++, Python, Go, and JavaScript, highlighting key differences in memory and mutability models Offers stack/heap and reference visualizations to clarify how ownership transfers and borrowing rules work in practice

INSTALLATION

npx skills add https://github.com/zhanghandong/rust-skills --skill m14-mental-model

Run in your project or agent environment. Adjust flags if your CLI version differs.

SKILL.md

Mental Models

Layer 2: Design Choices

Core Question

What's the right way to think about this Rust concept?

When learning or explaining Rust:

What's the correct mental model?

What misconceptions should be avoided?

What analogies help understanding?

Key Mental Models

Concept

Mental Model

Analogy

Ownership

Unique key

Only one person has the house key

Move

Key handover

Giving away your key

&T

Lending for reading

Lending a book

&mut T

Exclusive editing

Only you can edit the doc

Lifetime 'a

Valid scope

"Ticket valid until..."

Box<T>

Heap pointer

Remote control to TV

Rc<T>

Shared ownership

Multiple remotes, last turns off

Arc<T>

Thread-safe Rc

Remotes from any room

Coming From Other Languages

From

Key Shift

Java/C#

Values are owned, not references by default

C/C++

Compiler enforces safety rules

Python/Go

No GC, deterministic destruction

Functional

Mutability is safe via ownership

JavaScript

No null, use Option instead

Thinking Prompt

When confused about Rust:

What's the ownership model?

Who owns this data?

How long does it live?

Who can access it?

What guarantee is Rust providing?

No data races

No dangling pointers

No use-after-free

What's the compiler telling me?

Error = violation of safety rule

Solution = work with the rules

Trace Up ↑

To design understanding (Layer 2):

"Why can't I do X in Rust?"

    ↑ Ask: What safety guarantee would be violated?

    ↑ Check: m01-m07 for the rule being enforced

    ↑ Ask: What's the intended design pattern?

Trace Down ↓

To implementation (Layer 1):

"I understand the concept, now how do I implement?"

    ↓ m01-ownership: Ownership patterns

    ↓ m02-resource: Smart pointer choice

    ↓ m07-concurrency: Thread safety

Common Misconceptions

Error

Wrong Model

Correct Model

E0382 use after move

GC cleans up

Ownership = unique key transfer

E0502 borrow conflict

Multiple writers OK

Only one writer at a time

E0499 multiple mut borrows

Aliased mutation

Exclusive access for mutation

E0106 missing lifetime

Ignoring scope

References have validity scope

E0507 cannot move from &T

Implicit clone

References don't own data

Deprecated Thinking

Deprecated

Better

"Rust is like C++"

Different ownership model

"Lifetimes are GC"

Compile-time validity scope

"Clone solves everything"

Restructure ownership

"Fight the borrow checker"

Work with the compiler

"unsafe to avoid rules"

Understand safe patterns first

Ownership Visualization

Stack                          Heap

+----------------+            +----------------+

| main()         |            |                |

|   s1 ─────────────────────> │ "hello"        |

|                |            |                |

| fn takes(s) {  |            |                |

|   s2 (moved) ─────────────> │ "hello"        |

| }              |            | (s1 invalid)   |

+----------------+            +----------------+

After move: s1 is no longer valid

Reference Visualization

+----------------+

| data: String   |────────────> "hello"

+----------------+

       ↑

       │ &#x26;data (immutable borrow)

       │

+------+------+

| reader1    reader2    (multiple OK)

+------+------+

+----------------+

| data: String   |────────────> "hello"

+----------------+

       ↑

       │ &#x26;mut data (mutable borrow)

       │

+------+

| writer (only one)

+------+

Learning Path

Stage

Focus

Skills

Beginner

Ownership basics

m01-ownership, m14-mental-model

Intermediate

Smart pointers, error handling

m02, m06

Advanced

Concurrency, unsafe

m07, unsafe-checker

Expert

Design patterns

m09-m15, domain-*

Related Skills

When

See

Ownership errors

m01-ownership

Smart pointers

m02-resource

Concurrency

m07-concurrency

Anti-patterns

m15-anti-pattern