This article doesn’t aim to teach you Rust or unveil some hidden feature. It’s more like an experiment — a way to show a kid what Rust looks like on the inside (Rust, not the kid), rather than how to write idiomatic Rust code.

In other words, devs are used to judging a language by how well it fits into their mental model of “how code should be written.” And when it doesn’t? That’s when the frustration kicks in.

Here, I tried flipping the perspective — think “picture book”: how the language lives and breathes, not how we’ve learned to structure it.

⚠️ Disclaimer: This article isn’t about Copy types like i32, f64, bool, char, or &T. We're diving into move types — like String — where values are actually moved around.

Alright, let’s roll.

We’ll start with a core idea in Rust: a value (a memory cell) can only have one owner at a time.
Let’s introduce a bit of “storybook” notation:

let = “let it be”
= = “takes ownership”
mut = “money”, yep, just a money ;)

let

Let’s let a own a House:

let a = String::from("House");

Now let’s let b own that same House. According to the rules, the previous owner has to move out — no exceptions:

let b = a;

At this point:

println!("a = {}", a);

Boom — error.

Why? Because a no longer has the right to do anything with the value (its former House). Ownership was transferred, and Rust enforces that hard.

mut

But wait — there’s more. Just owning a House doesn’t mean you can start remodeling it. Think of it like renting someone else's place — ownership without modification rights.

So this will trigger an error:

b.push_str(" with Pool"); // 🔴 error

If you want to make changes, you have to buy the House with some extra money mut.

let mut c = b;
c.push_str(" with pool");
println!("{}", c); // House with pool

Now c has the keys and the renovation permit.

&

We can share access to the House — say, by letting a buddy crash for a while. You hand them a copy of the keys using &:

let d = &c;
println!("{}", c);
println!("{}", d);

But there’s a catch. According to the social contract, if guests are inside, no renovations allowed. The following code will throw an error:

let d = &c;
c.push_str(" with sandbox");// can't renovate while guests are over
println!("{}", c);
println!("{}", d);// guest is here

You have to wait until the guests leave:

let d = &c;
println!("{}", d);// guest leaves
c.push_str(" with sandbox");

Still confused? There’s a full “guest etiquette” section at the end of the article.

& mut

Now let’s say your buddy wants to add a hot tub. Since that’s a modification to the House, you ask him to chip in — and in return, you give him the real keys with change privileges: &mut.

let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", e);

Just remember: same rule applies — if someone else is holding the keys, you can’t do any remodeling. In fact, while your buddy is chilling in the hot tub, you can’t even enter the house:

let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", c);
println!("{}", e);// buddy’s in the hot tub 

You have to wait for them to finish:

let e = &mut c;
e.push_str(" and with hot tub");
println!("{}", e);// buddy’s done
println!("{}", c);

This only applies when you gave out “paid” access (&mut) — not when you just let someone couch-surf with &.

mut &mut

Now we rent out the House again — to another buddy, this time with full mod rights. But this buddy also has their own extra money — mut.

let mut f = &mut c;
f.push_str(" and with garden");

Things are going well, and we decide to buy a second place: Apartment.

let mut c2 = String::from("Apartment");

Our buddy’s not slacking either — “Let me try out the Apartment too,” he says, waving his mut wallet. So he moves out of the House, into the Apartment, and starts upgrading that too:

f = &mut c2;
f.push_str(" with elevator");

Same core idea: ownership with editing rights = &mut. And declaring let mut f means this buddy isn’t tied to just one location — he can move between places and make changes. Because money mut, yep

After he’s gone, we end up with both properties modified:

println!("c: {}", c);
println!("c2: {}", c2);
//c: House with pool and with sandbox and with hot tub and with garden
//c2: Apartment with elevator

Note: When I say “the buddy left,” I mean it literally — he’s gone, out of scope. Rust tracks that. If a variable is no longer used later in the code, Rust considers it dead — like you called delete on it.

That’s why things can seem weird: while the guest is “around,” you’re blocked from doing stuff, but it’s not always clear they’ve “left.” Rust figures it out by analyzing whether the variable is used again — if not, it’s safe to proceed.

Functions

With a few rare exceptions, the same rules apply to functions too. I won’t overload this post with function examples — maybe next time :)