• Each value in Rust has exactly one owner — when the owner goes out of scope, the value is dropped
• Assignment moves ownership by default; the original binding becomes invalid
• Borrowing (&T / &mut T) lets you reference data without taking ownership
• The compiler enforces: many shared references OR one mutable reference, never both
• No garbage collector needed — memory is freed deterministically at scope exit
// ERROR: value used after move
fn broken() {
let name = String::from("Alice");
let len = use_string(name); // ownership moves here
println!("{}", name); // ERROR: borrow of moved value: `name`
}
// FIX 1: clone before passing (explicit copy)
fn with_clone() {
let name = String::from("Alice");
let len = use_string(name.clone()); // clone stays, original moves
let len2 = use_string(name); // now name moves here — fine
}
// FIX 2: pass a reference instead (borrow, don't move)
fn use_string_ref(s: &String) -> usize {
s.len() // s is borrowed, not owned — caller keeps it
}
fn with_borrow() {
let name = String::from("Alice");
let len = use_string_ref(&name); // borrow: name is still valid
println!("{} has {} chars", name, len); // works!
}
// Copy types don't move — they're silently duplicated
fn copy_demo() {
let x: i32 = 42;
let y = x; // Copy, not move — both remain valid
println!("{} {}", x, y); // fine
}| Concept | OCaml | Rust |
|---|---|---|
| Memory management | GC (reference counting + tracing) | Ownership (compile-time) |
| Passing a value | Shares a GC pointer — original stays valid | Moves ownership — original invalid |
| Reuse after pass | Always works | Only if `Copy` or explicitly `.clone()`d |
| "Use after move" | Impossible concept | Compile error |
| Runtime cost | GC pauses and overhead | Zero-cost (no GC) |
// Example 101: Move Semantics — Rust Ownership Transfer
//
// In Rust, values have a single owner. When you pass a value to a function,
// ownership transfers (moves) and the original binding becomes invalid.
// Approach 1: Demonstrating move with String (heap-allocated)
fn use_string(s: String) -> usize {
println!("Using: {}", s);
s.len()
// s is dropped here
}
fn approach1() {
let greeting = String::from("Hello, ownership!");
let len1 = use_string(greeting);
// greeting is MOVED — can't use it again!
// let len2 = use_string(greeting); // ERROR: value used after move
// Instead, we must create a new one or clone
let greeting2 = String::from("Hello, ownership!");
let len2 = use_string(greeting2);
assert_eq!(len1, len2);
println!("Lengths: {}, {}", len1, len2);
}
// Approach 2: Using clone to keep both copies
fn approach2() {
let greeting = String::from("Hello, ownership!");
let len1 = use_string(greeting.clone()); // clone before move
let len2 = use_string(greeting); // now move the original
assert_eq!(len1, len2);
println!("Clone approach — both used successfully");
}
// Approach 3: Move with structs
#[derive(Debug)]
struct Person {
name: String,
age: u32,
}
fn greet(p: Person) {
println!("Hello, {} (age {})!", p.name, p.age);
// p is consumed here
}
fn approach3() {
let p = Person {
name: String::from("Alice"),
age: 30,
};
greet(p);
// greet(p); // ERROR: p was moved
// With Copy types (like integers), no move occurs
let x = 42;
let y = x; // Copy, not move
println!("x={}, y={} — both valid because i32 is Copy", x, y);
}
fn main() {
println!("=== Approach 1: Basic Move ===");
approach1();
println!("\n=== Approach 2: Clone Before Move ===");
approach2();
println!("\n=== Approach 3: Struct Move vs Copy Types ===");
approach3();
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_string_move() {
let s = String::from("test");
let len = use_string(s);
assert_eq!(len, 4);
}
#[test]
fn test_clone_preserves_value() {
let s = String::from("hello");
let s2 = s.clone();
assert_eq!(s, s2);
assert_eq!(use_string(s), use_string(s2));
}
#[test]
fn test_copy_types_dont_move() {
let x: i32 = 42;
let y = x;
assert_eq!(x, y); // both still valid
}
#[test]
fn test_move_into_vec() {
let s = String::from("hello");
let mut v = Vec::new();
v.push(s);
// s is moved into vec
assert_eq!(v[0], "hello");
}
#[test]
fn test_move_out_of_option() {
let mut opt = Some(String::from("data"));
let taken = opt.take(); // moves out, replaces with None
assert!(opt.is_none());
assert_eq!(taken.unwrap(), "data");
}
}
(* Example 101: Move Semantics — OCaml GC vs Rust Ownership Transfer *)
(* In OCaml, all values are garbage-collected. "Moving" doesn't exist —
you just share references and the GC cleans up. *)
(* Approach 1: Simple value passing — OCaml shares freely *)
let use_string s =
Printf.printf "Using: %s\n" s;
String.length s
let approach1 () =
let greeting = "Hello, ownership!" in
let len1 = use_string greeting in
(* In OCaml, we can use greeting again — no move happened *)
let len2 = use_string greeting in
assert (len1 = len2);
Printf.printf "Used greeting twice, lengths: %d, %d\n" len1 len2
(* Approach 2: Passing structured data — still no move *)
type person = { name : string; age : int }
let greet p =
Printf.printf "Hello, %s (age %d)!\n" p.name p.age
let approach2 () =
let p = { name = "Alice"; age = 30 } in
greet p;
greet p; (* No problem — p is still accessible *)
Printf.printf "Person %s is still here\n" p.name
(* Approach 3: Simulating ownership transfer with option ref *)
let take_ownership (slot : string option ref) =
match !slot with
| Some s ->
slot := None; (* "consume" the value *)
Printf.printf "Took ownership of: %s\n" s;
s
| None ->
failwith "Value already moved!"
let approach3 () =
let data = ref (Some "precious data") in
let _taken = take_ownership data in
(* Trying again would fail — simulating Rust's move *)
(try
let _ = take_ownership data in ()
with Failure msg ->
Printf.printf "Caught: %s\n" msg);
Printf.printf "Simulated move semantics in OCaml\n"
(* Tests *)
let () =
approach1 ();
approach2 ();
approach3 ();
Printf.printf "✓ All tests passed\n"
OCaml — values are shared via GC:
🐪 Show OCaml equivalent
let use_string s =
Printf.printf "Using: %s\n" s;
String.length s
let () =
let greeting = "Hello!" in
let _ = use_string greeting in
let _ = use_string greeting in (* fine — GC manages it *)
()
Rust — values are moved (consumed):
fn use_string(s: String) -> usize {
println!("Using: {}", s);
s.len()
}
fn main() {
let greeting = String::from("Hello!");
let _ = use_string(greeting);
// let _ = use_string(greeting); // ERROR: moved
}OCaml — automatic, no action needed:
🐪 Show OCaml equivalent
let a = [1; 2; 3] in
let b = a in (* both a and b point to same list *)
assert (a = b)
Rust — explicit clone required:
let a = vec![1, 2, 3];
let b = a.clone(); // explicit copy
// let b = a; // this would MOVE, making a invalid
assert_eq!(a, b);OCaml — manual protocol with option ref:
🐪 Show OCaml equivalent
let take (slot : string option ref) =
match !slot with
| Some s -> slot := None; s
| None -> failwith "already moved"
Rust — built into the language:
let mut opt = Some(String::from("data"));
let taken = opt.take(); // Option::take moves out
assert!(opt.is_none());OCaml — everything is "copy-like" (GC-managed):
🐪 Show OCaml equivalent
let x = 42 in
let y = x in (* both valid, always *)
Rust — only `Copy` types avoid move:
let x: i32 = 42;
let y = x; // Copy, not move — both valid
let s = String::from("hi");
let t = s; // Move! s is invalid now