actionbook/rust-skills

m14-mental-model

Use when learning Rust concepts.

소스 보기

사용 방법

  1. 설치 명령을 복사하고 자신의 에이전트 환경에 설치하기 전에 소스 패키지를 확인하세요.
  2. 필요한 도구, 인증 정보, 지원 환경은 원본 문서에서 확인하세요.
  3. 입력과 원하는 산출물을 설명하고 출처와 결과를 대조하세요.
npx skills add https://github.com/actionbook/rust-skills --skill m14-mental-model

시작 전 확인

  • 설치에는 모델 구독, API 한도, 파일 접근 권한이 포함되지 않습니다.
  • 별점 수와 설치 수는 활동 지표이며 독립적인 품질·보안 검증이 아닙니다.
원본 Skill 문서

원본 저장소의 제목, 예시, 코드, 표, 링크, 이미지를 유지해 표시합니다.

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

ConceptMental ModelAnalogy
OwnershipUnique keyOnly one person has the house key
MoveKey handoverGiving away your key
&TLending for readingLending a book
&mut TExclusive editingOnly you can edit the doc
Lifetime 'aValid scope"Ticket valid until..."
Box<T>Heap pointerRemote control to TV
Rc<T>Shared ownershipMultiple remotes, last turns off
Arc<T>Thread-safe RcRemotes from any room

Coming From Other Languages

FromKey Shift
Java/C#Values are owned, not references by default
C/C++Compiler enforces safety rules
Python/GoNo GC, deterministic destruction
FunctionalMutability is safe via ownership
JavaScriptNo null, use Option instead

Thinking Prompt

When confused about Rust:

  1. What's the ownership model?
  • Who owns this data?
  • How long does it live?
  • Who can access it?
  1. What guarantee is Rust providing?
  • No data races
  • No dangling pointers
  • No use-after-free
  1. 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

ErrorWrong ModelCorrect Model
E0382 use after moveGC cleans upOwnership = unique key transfer
E0502 borrow conflictMultiple writers OKOnly one writer at a time
E0499 multiple mut borrowsAliased mutationExclusive access for mutation
E0106 missing lifetimeIgnoring scopeReferences have validity scope
E0507 cannot move from &TImplicit cloneReferences don't own data

Deprecated Thinking

DeprecatedBetter
"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"
+----------------+
       ↑
       │ &data (immutable borrow)
       │
+------+------+
| reader1    reader2    (multiple OK)
+------+------+

+----------------+
| data: String   |────────────> "hello"
+----------------+
       ↑
       │ &mut data (mutable borrow)
       │
+------+
| writer (only one)
+------+

Learning Path

StageFocusSkills
BeginnerOwnership basicsm01-ownership, m14-mental-model
IntermediateSmart pointers, error handlingm02, m06
AdvancedConcurrency, unsafem07, unsafe-checker
ExpertDesign patternsm09-m15, domain-*

Related Skills

WhenSee
Ownership errorsm01-ownership
Smart pointersm02-resource
Concurrencym07-concurrency
Anti-patternsm15-anti-pattern

관련 작업

같은 저장소의 Skills

더 많은 Skills

모든 Skills
actionbook
커뮤니티

domain-embedded

Use when developing embedded/nostd Rust. Keywords: embedded, nostd, microcontroller, MCU, ARM, RISC-V, bare metal, firmware, HAL, PAC, RTIC, embassy, interrupt, DMA, peripheral, GPIO, SPI, I2C, UART, embedded-hal, cortex-m, esp32, stm32, nrf, 嵌入式, 单片机, 固件, 裸机

1시간 설치 수
1
GitHub Stars
1.6천
업데이트
8월 23일
actionbook
커뮤니티

m15-anti-pattern

Use when reviewing code for anti-patterns. Keywords: anti-pattern, common mistake, pitfall, code smell, bad practice, code review, is this an anti-pattern, better way to do this, common mistake to avoid, why is this bad, idiomatic way, beginner mistake, fighting borrow checker, clone everywhere, unwrap in production, should I refactor, 反模式, 常见错误, 代码异味, 最佳实践, 地道写法

1시간 설치 수
14
GitHub Stars
1.6천
업데이트
8월 23일
actionbook
커뮤니티

coding-guidelines

Use when asking about Rust code style or best practices. Keywords: naming, formatting, comment, clippy, rustfmt, lint, code style, best practice, P.NAM, G.FMT, code review, naming convention, variable naming, function naming, type naming, 命名规范, 代码风格, 格式化, 最佳实践, 代码审查, 怎么命名

1시간 설치 수
2
GitHub Stars
1.5천
업데이트
8월 23일
actionbook
커뮤니티

m03-mutability

CRITICAL: Use for mutability issues. Triggers: E0596, E0499, E0502, cannot borrow as mutable, already borrowed as immutable, mut, &mut, interior mutability, Cell, RefCell, Mutex, RwLock, 可变性, 内部可变性, 借用冲突

1시간 설치 수
2
GitHub Stars
1.5천
업데이트
8월 23일