____  ____   ___  _____  ___  _______   ______  _____
|  _ \|  _ \ / _ \|_   _|/ _ \|_   _\ \ / /  _ \| ____|
| |_) | |_) | | | | | | | | | | | |  \ V /| |_) |  _|
|  __/|  _ <| |_| | | | | |_| | | |   | | |  __/| |___
|_|   |_| \_\\___/  |_|  \___/  |_|   |_| |_|   |_____|
                                              .rs
    _~^~^~_
\) /  o o  \ (/
  '_   -   _'
  / '-----' \
user@prototype:~$
// ---- section break ---- //
user@prototype:~$
✓ Compiled successfully in 0.42s

Welcome to prototype.rs -- a living workspace for Rust prototypes in various stages of development. Here, code is written not to ship but to explore. Every prototype is an experiment, a question asked in syntax and answered by the compiler.

The philosophy is simple: write it, compile it, learn from it, iterate. The borrow checker is not an obstacle but a teacher. Every lifetime annotation is a lesson in ownership. Every trait bound is a contract with the future.

// ---- section break ---- //
user@prototype:~$
warning[E0599]: ownership model demonstration
1| let prototype = String::from("idea");
2| let refined = prototype;
3| // prototype has been moved
| ^^^^^^^^^^ value used here after move

In Rust, ownership is the fundamental contract. When a value moves, the original binding is invalidated. This is not a limitation -- it is a guarantee. The prototype teaches us: once an idea evolves, you cannot go back to the original. You can only move forward with the refined version.

// Ownership teaches us that growth requires letting go

// ---- section break ---- //
user@prototype:~$
error[E0382]: borrowed value does not live long enough
7| fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
8| if x.len() > y.len() { x } else { y }
9| }
| - help: consider adding lifetime annotation

Lifetimes are Rust's way of ensuring references never outlive the data they point to. Every prototype has a lifetime -- a scope within which it is valid and useful. Beyond that scope, it must be released. The compiler enforces what good engineering practice recommends: know your dependencies, respect your constraints.

// Every reference has a story; lifetimes tell it

// ---- section break ---- //
user@prototype:~$
✓ Compiled successfully in 0.38s

Traits define shared behavior across types -- a contract that says "I can do this." In the prototype workshop, traits are the interfaces between ideas. A Displayable prototype can present itself. A Cloneable prototype can be duplicated for parallel experimentation. A Debuggable prototype reveals its internal state.

The elegance of traits is that they define capability without prescribing implementation. Each prototype implements the same interface differently, and the compiler ensures they all fulfill the contract. Zero-cost abstractions at their finest.

// ---- section break ---- //
user@prototype:~$
Compiling prototype-rs v1.0.0
✓ prototype.rs v1.0.0 -- all tests passing

Build complete. All prototypes compiled, tested, and verified. The borrow checker approves. The type system confirms. Memory safety guaranteed at compile time. No garbage collector needed, no runtime overhead. Just clean, verified code ready for the next iteration.

// The compiler is satisfied. For now.

user@prototype:~$