Rust Ownership And Borrowing Explained Practice Exam

Question 1 Rust Ownership And Borrowing Explained

What is `Arc<T>`?

A reader-writer lock: many concurrent shared readers OR one exclusive writer, with runtime enforcement. Yes. drop is invoked automatically at the end of a value's scope, in reverse order of declaration. An atomically reference-counted smart pointer for shared ownership across threads; same API as Rc but uses atomic operations. Use the deref coercion &s where s: String, or call &s[..], or s.as_str().

Question 2 Rust Ownership And Borrowing Explained

Can shadowing change a variable's type?

You can implement a foreign trait for a foreign type only if at least one of the trait or type is local to your crate. Because the iterator's lifetime parameter is tied to the borrow of the vector; the iterator cannot outlive the vector's borrow. An automatic coercion that converts a reference to a type that implements Deref into a reference to the type it derefs to (e.g. &String to &str). Yes. Unlike mutation, shadowing can rebind a name to a value of a different type.

Question 3 Rust Ownership And Borrowing Explained

Which standard library function is called when a value goes out of scope?

To control variance and to ensure the borrow/drop checker considers the inner T even though it is not stored directly. It prevents data races at compile time and underpins the correctness of compiler optimizations like the LLVM noalias attribute used on &mut T. A reference that points to memory that has been freed or to a value that has gone out of scope; Rust's borrow checker prevents them at compile time. drop, from the Drop trait, is called automatically at the end of the variable's scope.

Question 4 Rust Ownership And Borrowing Explained

How do you give ownership back from a function without moving?

Borrowing is the act of passing a reference to a value rather than transferring ownership, so the original owner retains it. Write T: ?Sized as a trait bound, allowing the parameter to be a DST like str or [T]. Return the value (moves it to the caller) or return a reference whose lifetime is tied to an input or to 'static. A block of code delimited by { }; variables declared inside it are dropped at the closing brace.

Question 5 Rust Ownership And Borrowing Explained

What does the `Deref` trait do?

Copy is an implicit, bitwise copy marker with no custom behavior; Clone is an explicit method (.clone()) that may perform arbitrary, potentially expensive duplication. It allows a type to be dereferenced with * and enables implicit coercion from &T to &U when T: Deref<Target = U>. A data race is concurrent unsynchronized access where at least one is a write; safe Rust's type system prevents data races because &mut T is Send only when the type is Send and shared access requires Sync. A zero-sized marker that tells the compiler a type acts as if it owns or borrows a T, for variance, drop check, and auto-trait purposes.

Question 6 Rust Ownership And Borrowing Explained

Why is `PhantomData` used in smart-pointer-like types?

In intrusive collections and low-level smart pointers (e.g. linked-list implementations) that must drop even when their owned references are no longer valid. To control variance and to ensure the borrow/drop checker considers the inner T even though it is not stored directly. Redeclaring a variable with the same name in the same scope using let; the new binding shadows the old until the new one goes out of scope or is shadowed again. That the Parser borrows a string slice that must live at least as long as the Parser itself.

Question 7 Rust Ownership And Borrowing Explained

What does `[..]`, `[a..]`, `[..b]`, and `[a..b]` mean for ranges?

Full slice; from a to end; from start to b (exclusive); elements a to b (exclusive). Exactly one. Two mutable references to the same data in the same scope are a compile-time error. A generic parameter like struct Ref<'a> { r: &'a i32 } that says the struct cannot outlive the data it borrows. Creates a deep copy of the value, producing a new, independent owner; it requires the Clone trait.

Question 8 Rust Ownership And Borrowing Explained

What is a "PhantomData<fn(T) -> T>" trick used for?

To make a type covariant in T only (not contravariant), or to indicate a function-like relationship; PhantomData<T> makes a type own or borrow T with default variance. That the Parser borrows a string slice that must live at least as long as the Parser itself. Copy is an implicit, bitwise copy marker with no custom behavior; Clone is an explicit method (.clone()) that may perform arbitrary, potentially expensive duplication. A type whose size is not known at compile time, such as [T] and str; DSTs can only be used behind a pointer like &[T] or Box<[T]>.

Question 9 Rust Ownership And Borrowing Explained

What is the elision rule for lifetimes in function signatures?

Each input reference gets its own lifetime, and if there is exactly one input reference, its lifetime is assigned to all output references. A lifetime that lasts for the entire duration of the program. String literals are &'static str. Yes. drop is invoked automatically at the end of a value's scope, in reverse order of declaration. When a function takes &[T], you can pass &Vec<T> and it coerces automatically via Vec<T>: Deref<Target = [T]>.

Question 10 Rust Ownership And Borrowing Explained

Does shadowing move or drop the old variable?

You can implement a foreign trait for a foreign type only if at least one of the trait or type is local to your crate. Indicates that a value can be safely shared between threads via &T; it is automatically implemented if &T is Send. No. The old variable's value is still valid until its own scope ends; shadowing simply makes the name refer to a new value. Yes. Each match arm body is a new scope; bindings introduced inside it are dropped at the end of the arm.

Question 11 Rust Ownership And Borrowing Explained

Can a type be `Copy` if it also implements `Drop`?

References are Copy, so the tuple is Copy; assignment copies the reference, not the pointed-to data. To pin a value at a stable memory address so it cannot be moved, enabling safe self-referential data structures and async state machines. No. The compiler rejects types that implement both Copy and Drop, because Copy implies no special cleanup is needed. A data race is concurrent unsynchronized access where at least one is a write; safe Rust's type system prevents data races because &mut T is Send only when the type is Send and shared access requires Sync.

Question 12 Rust Ownership And Borrowing Explained

Why is "ownership of the iterator returned by `vec.iter()`" tied to the borrow?

A clone-on-write enum Borrowed(&'a T) | Owned(<T as ToOwned>::Owned) that avoids cloning when a borrowed value is sufficient. for x in collection uses into_iter() by default, consuming the collection; use iter() or iter_mut() to iterate by reference. Because the iterator's lifetime parameter is tied to the borrow of the vector; the iterator cannot outlive the vector's borrow. Cell<T> works only for Copy types and has no runtime borrow tracking; RefCell<T> works for any T but tracks borrows at runtime and can panic.

Question 13 Rust Ownership And Borrowing Explained

What is "ownership of an array literal `[1, 2, 3]`"?

A compile-time analysis that ensures generic types cannot outlive values they may need to drop; PhantomData participates in this check. It is an array of Copy elements, so the array itself is Copy and is duplicated on assignment without moving. It enforces Rust's aliasing rules at runtime via reference counts: at most one mutable borrow OR many shared borrows at a time; violations cause a panic!. Types with a known fixed size and no heap-allocated contents, like i32, (i32, i32), arrays of Copy types, and structs containing only such fields.

Question 14 Rust Ownership And Borrowing Explained

Where is a `String`'s actual character data stored?

pub trait Clone { fn clone(&self) -> Self; } — it takes a shared reference and returns an owned value. *const T is covariant in T; *mut T is invariant in T. On the heap. The String struct itself (pointer, length, capacity) lives on the stack, and the buffer it points to is on the heap. It allows a type to be dereferenced with * and enables implicit coercion from &T to &U when T: Deref<Target = U>.

Question 15 Rust Ownership And Borrowing Explained

Does `match` create a new scope?

Yes. Each match arm body is a new scope; bindings introduced inside it are dropped at the end of the arm. Borrowing is the act of passing a reference to a value rather than transferring ownership, so the original owner retains it. No. The compiler guarantees references always point to valid data — code that would create a dangling reference fails to compile. No. &str is a shared (immutable) reference. You need String or &mut str to mutate.

Question 16 Rust Ownership And Borrowing Explained

What is "auto-deref" when calling methods?

Method resolution repeatedly dereferences the receiver with Deref until a method is found, so s.len() works for s: String via Deref<Target = str>. A Box<T> is a smart pointer that owns a heap-allocated T; when the box is dropped, the inner T is dropped. Indicates that ownership of a value can be transferred safely between threads. &'static str — an immutable reference to a string slice with 'static lifetime.

Question 17 Rust Ownership And Borrowing Explained

Why does Rust forbid returning a reference to a local variable?

Because the iterator's lifetime parameter is tied to the borrow of the vector; the iterator cannot outlive the vector's borrow. No. The compiler guarantees references always point to valid data — code that would create a dangling reference fails to compile. Borrowing is the act of passing a reference to a value rather than transferring ownership, so the original owner retains it. Because the local is dropped at the end of the function, leaving a dangling reference; the borrow checker rejects it at compile time.

Question 18 Rust Ownership And Borrowing Explained

What does the `Copy` trait inherit from?

A Box<T> is a smart pointer that owns a heap-allocated T; when the box is dropped, the inner T is dropped. Copy is a marker trait (a unit trait) that requires implementing Clone. Creates a deep copy of the value, producing a new, independent owner; it requires the Clone trait. Generic parameters (e.g. 'a) on references that tell the compiler how multiple references relate in time.

Question 19 Rust Ownership And Borrowing Explained

What does `ref mut` do in a pattern?

When a function takes &[T], you can pass &Vec<T> and it coerces automatically via Vec<T>: Deref<Target = [T]>. It binds the matched value by mutable reference, e.g. let Foo { ref mut x } = f; gives x: &mut T. A reference to a contiguous sequence of elements plus a length — written &[T] (shared) or &mut [T] (mutable) — that always borrows data. Neither covariant nor contravariant: no implicit subtype substitution is allowed in that position.

Question 20 Rust Ownership And Borrowing Explained

What is a lifetime parameter on a struct?

When you destructure a struct and move out some fields while leaving others, the whole struct becomes partially moved; the moved fields can be used, but accessing the unmoved parts through the original binding is forbidden. A reference that points to memory that has been freed or to a value that has gone out of scope; Rust's borrow checker prevents them at compile time. No. The compiler guarantees references always point to valid data — code that would create a dangling reference fails to compile. A generic parameter like struct Ref<'a> { r: &'a i32 } that says the struct cannot outlive the data it borrows.

Question 21 Rust Ownership And Borrowing Explained

What is the "aliasing XOR mutability" rule of Rust references?

drop, from the Drop trait, is called automatically at the end of the variable's scope. You can implement a foreign trait for a foreign type only if at least one of the trait or type is local to your crate. At any program point, a value is either accessed via any number of shared (&) references or via exactly one mutable (&mut) reference — never both. An enum owns exactly the data of one of its variants; moving the enum moves the data of that variant.

Question 22 Rust Ownership And Borrowing Explained

What is a "scope" in Rust?

It binds the matched value by reference, e.g. let Foo { ref x } = f; gives x: &T instead of moving x out of f. A constraint like T: 'a meaning all references in T must outlive the lifetime 'a. Types with a known fixed size and no heap-allocated contents, like i32, (i32, i32), arrays of Copy types, and structs containing only such fields. A block of code delimited by { }; variables declared inside it are dropped at the closing brace.

Question 23 Rust Ownership And Borrowing Explained

At what point does the borrow checker run?

String is an owned, growable, heap-allocated UTF-8 string; &str is an immutable borrowed view (slice) into UTF-8 data. At compile time, on every Rust program; it is the core of Rust's memory safety guarantees without a garbage collector. A lifetime that lasts for the entire duration of the program. String literals are &'static str. Rc is not Send/Sync and is faster (non-atomic counts); Arc is thread-safe but slightly slower due to atomic operations.

Question 24 Rust Ownership And Borrowing Explained

What is a dangling reference?

Creates a deep copy of the value, producing a new, independent owner; it requires the Clone trait. A reference that points to memory that has been freed or to a value that has gone out of scope; Rust's borrow checker prevents them at compile time. Yes. Unlike mutation, shadowing can rebind a name to a value of a different type. Each value in Rust has an owner. There can only be one owner at a time. When the owner goes out of scope, the value is dropped.

Question 25 Rust Ownership And Borrowing Explained

What is the "interior mutability" pattern?

When a function takes &[T], you can pass &Vec<T> and it coerces automatically via Vec<T>: Deref<Target = [T]>. Types like Cell<T> and RefCell<T> allow mutation through a shared reference, with the mutability rules enforced at runtime instead of compile time. To make a type covariant in T only (not contravariant), or to indicate a function-like relationship; PhantomData<T> makes a type own or borrow T with default variance. No. The compiler guarantees references always point to valid data — code that would create a dangling reference fails to compile.

Question 26 Rust Ownership And Borrowing Explained

What does "NLL" stand for and when was it stabilized?

&mut T is invariant in T: you cannot substitute a subtype or supertype because the mutability gives write access. Copy and Clone. Types implementing Copy (e.g. integers, bool, char, tuples of Copy types) are copied on assignment; Clone is an explicit .clone() method. Indicates that a value can be safely shared between threads via &T; it is automatically implemented if &T is Send. Non-Lexical Lifetimes, stabilized in Rust 1.31 (December 2018).

Question 27 Rust Ownership And Borrowing Explained

What is the difference between `String` and `&str`?

String is an owned, growable, heap-allocated UTF-8 string; &str is an immutable borrowed view (slice) into UTF-8 data. At compile time, on every Rust program; it is the core of Rust's memory safety guarantees without a garbage collector. To make a type covariant in T only (not contravariant), or to indicate a function-like relationship; PhantomData<T> makes a type own or borrow T with default variance. It allows a type to be dereferenced with * and enables implicit coercion from &T to &U when T: Deref<Target = U>.

Question 28 Rust Ownership And Borrowing Explained

What is "partial move" in a struct pattern?

No. s1 is invalidated by the move; using it is a compile-time error. When you destructure a struct and move out some fields while leaving others, the whole struct becomes partially moved; the moved fields can be used, but accessing the unmoved parts through the original binding is forbidden. A reader-writer lock: many concurrent shared readers OR one exclusive writer, with runtime enforcement. A reference that points to memory that has been freed or to a value that has gone out of scope; Rust's borrow checker prevents them at compile time.

Question 29 Rust Ownership And Borrowing Explained

Which traits enable copy-by-value rather than moving?

A non-owning reference counted alongside Rc/Arc that does not keep the value alive; upgraded via upgrade() returning Option<Rc<T>>. A reference-counted smart pointer for single-threaded shared ownership; clone increments the count, drop decrements it, and the inner value is freed at zero. Copy and Clone. Types implementing Copy (e.g. integers, bool, char, tuples of Copy types) are copied on assignment; Clone is an explicit .clone() method. A transfer of ownership: assigning a value to another variable or passing it to a function moves the value, invalidating the source binding.

Question 30 Rust Ownership And Borrowing Explained

What is the `Copy` semantics for tuple of references like `&(i32, i32)`?

It binds the matched value by reference, e.g. let Foo { ref x } = f; gives x: &T instead of moving x out of f. Any number, but they cannot coexist with a mutable reference to the same value in the same scope. Yes. drop is invoked automatically at the end of a value's scope, in reverse order of declaration. References are Copy, so the tuple is Copy; assignment copies the reference, not the pointed-to data.

Question 31 Rust Ownership And Borrowing Explained

What is a "data race" and can safe Rust produce one?

A reference (&T for shared, &mut T for mutable) is a non-owning pointer to a value, governed by the borrow checker. Returning a value transfers ownership to the caller; the caller becomes the new owner and is responsible for dropping it. A data race is concurrent unsynchronized access where at least one is a write; safe Rust's type system prevents data races because &mut T is Send only when the type is Send and shared access requires Sync. It prevents data races at compile time and underpins the correctness of compiler optimizations like the LLVM noalias attribute used on &mut T.

Question 32 Rust Ownership And Borrowing Explained

What is the difference between `Copy` and `Clone`?

Copy is an implicit, bitwise copy marker with no custom behavior; Clone is an explicit method (.clone()) that may perform arbitrary, potentially expensive duplication. The syntax for<'a> F: Fn(&'a T) -> &'a T, expressing that a bound must hold for every possible lifetime. At compile time, on every Rust program; it is the core of Rust's memory safety guarantees without a garbage collector. Each input reference gets its own lifetime, and if there is exactly one input reference, its lifetime is assigned to all output references.

Question 33 Rust Ownership And Borrowing Explained

What is the difference between `Cell` and `RefCell`?

Resource Acquisition Is Initialization: resources are tied to object lifetimes, and a type's Drop implementation releases them when the value goes out of scope. A compile-time analysis that ensures generic types cannot outlive values they may need to drop; PhantomData participates in this check. Cell<T> works only for Copy types and has no runtime borrow tracking; RefCell<T> works for any T but tracks borrows at runtime and can panic. A reader-writer lock: many concurrent shared readers OR one exclusive writer, with runtime enforcement.

Question 34 Rust Ownership And Borrowing Explained

How do you obtain a `&str` from a `String`?

Use the deref coercion &s where s: String, or call &s[..], or s.as_str(). At compile time, on every Rust program; it is the core of Rust's memory safety guarantees without a garbage collector. A trait with a single method fn drop(&mut self) that runs custom cleanup code when a value goes out of scope. A reference to an i32 that lives at least as long as the lifetime 'a.

Question 35 Rust Ownership And Borrowing Explained

What is the difference between `&Vec<T>` and `&[T]` as function parameters?

String::from("hello") or "hello".to_string(). Yes. Each match arm body is a new scope; bindings introduced inside it are dropped at the end of the arm. Moving avoids double-free bugs and keeps the type system simple — for stack-allocated types that own heap data (like String), copying the pointer would leave two owners. &Vec<T> requires a specific type; &[T] is more flexible — it accepts vectors, arrays, and slices thanks to deref/unsized coercion.

Question 36 Rust Ownership And Borrowing Explained

What is borrowing?

A generic parameter like struct Ref<'a> { r: &'a i32 } that says the struct cannot outlive the data it borrows. A data race is concurrent unsynchronized access where at least one is a write; safe Rust's type system prevents data races because &mut T is Send only when the type is Send and shared access requires Sync. Borrowing is the act of passing a reference to a value rather than transferring ownership, so the original owner retains it. A compile-time analysis that ensures generic types cannot outlive values they may need to drop; PhantomData participates in this check.

Question 37 Rust Ownership And Borrowing Explained

What is the difference between `Rc` and `Arc`?

Rc is not Send/Sync and is faster (non-atomic counts); Arc is thread-safe but slightly slower due to atomic operations. A reference (&T for shared, &mut T for mutable) is a non-owning pointer to a value, governed by the borrow checker. Use the deref coercion &s where s: String, or call &s[..], or s.as_str(). In intrusive collections and low-level smart pointers (e.g. linked-list implementations) that must drop even when their owned references are no longer valid.

Question 38 Rust Ownership And Borrowing Explained

What is the `Send` marker trait?

Copy is an implicit, bitwise copy marker with no custom behavior; Clone is an explicit method (.clone()) that may perform arbitrary, potentially expensive duplication. Redeclaring a variable with the same name in the same scope using let; the new binding shadows the old until the new one goes out of scope or is shadowed again. Cell<T> works only for Copy types and has no runtime borrow tracking; RefCell<T> works for any T but tracks borrows at runtime and can panic. Indicates that ownership of a value can be transferred safely between threads.

Question 39 Rust Ownership And Borrowing Explained

What is `Weak<T>`?

A block of code delimited by { }; variables declared inside it are dropped at the closing brace. A non-owning reference counted alongside Rc/Arc that does not keep the value alive; upgraded via upgrade() returning Option<Rc<T>>. Because the compiler ties the binding to the specific variant in the arm; if a variant binds by value, the inner data is moved into that binding. A reference (&T for shared, &mut T for mutable) is a non-owning pointer to a value, governed by the borrow checker.

Question 40 Rust Ownership And Borrowing Explained

What is the `Sync` marker trait?

Yes. Unlike mutation, shadowing can rebind a name to a value of a different type. Because the iterator's lifetime parameter is tied to the borrow of the vector; the iterator cannot outlive the vector's borrow. Indicates that a value can be safely shared between threads via &T; it is automatically implemented if &T is Send. References are Copy, so the tuple is Copy; assignment copies the reference, not the pointed-to data.

Question 41 Rust Ownership And Borrowing Explained

What does the `Ref` type represent?

A guard returned by RefCell::borrow() that acts as a shared reference to the inner data and releases the borrow on drop. Yes. drop is invoked automatically at the end of a value's scope, in reverse order of declaration. A cycle of references (e.g. via Rc<RefCell<T>>) where items keep each other alive; Rust's compile-time rules cannot prevent these, so they can leak. Write T: ?Sized as a trait bound, allowing the parameter to be a DST like str or [T].

Question 42 Rust Ownership And Borrowing Explained

Which Rust types are stored entirely on the stack?

Types with a known fixed size and no heap-allocated contents, like i32, (i32, i32), arrays of Copy types, and structs containing only such fields. Ownership of the heap allocation transfers to the new owner; the original Box binding is invalidated. It prevents data races at compile time and underpins the correctness of compiler optimizations like the LLVM noalias attribute used on &mut T. It is dropped — its drop function runs and its memory is freed.

Question 43 Rust Ownership And Borrowing Explained

What is a "higher-ranked trait bound" (HRTB)?

That the Parser borrows a string slice that must live at least as long as the Parser itself. Method resolution repeatedly dereferences the receiver with Deref until a method is found, so s.len() works for s: String via Deref<Target = str>. The syntax for<'a> F: Fn(&'a T) -> &'a T, expressing that a bound must hold for every possible lifetime. Copy is an implicit, bitwise copy marker with no custom behavior; Clone is an explicit method (.clone()) that may perform arbitrary, potentially expensive duplication.

Question 44 Rust Ownership And Borrowing Explained

Can you have a mutable and an immutable reference to the same value at the same time?

A reference-counted smart pointer for single-threaded shared ownership; clone increments the count, drop decrements it, and the inner value is freed at zero. A data race is concurrent unsynchronized access where at least one is a write; safe Rust's type system prevents data races because &mut T is Send only when the type is Send and shared access requires Sync. Generic parameters (e.g. 'a) on references that tell the compiler how multiple references relate in time. No. While a mutable reference exists, no immutable references may exist (and vice versa) for the same data in the same scope.

Question 45 Rust Ownership And Borrowing Explained

What is `PhantomData<T>`?

References are Copy, so the tuple is Copy; assignment copies the reference, not the pointed-to data. Mutation (let mut x) changes the value in place while keeping the type and binding; shadowing rebinds the name, possibly to a new type or value. A zero-sized marker that tells the compiler a type acts as if it owns or borrows a T, for variance, drop check, and auto-trait purposes. It enforces Rust's aliasing rules at runtime via reference counts: at most one mutable borrow OR many shared borrows at a time; violations cause a panic!.

Question 46 Rust Ownership And Borrowing Explained

What is the "static lifetime `'static`"?

At any program point, a value is either accessed via any number of shared (&) references or via exactly one mutable (&mut) reference — never both. A lifetime that lasts for the entire duration of the program. String literals are &'static str. A transfer of ownership: assigning a value to another variable or passing it to a function moves the value, invalidating the source binding. Accessing memory after it has been freed; the borrow checker prevents this at compile time by ensuring references never outlive their referent.

Question 47 Rust Ownership And Borrowing Explained

What is the difference between mutation and shadowing?

It prevents data races at compile time and underpins the correctness of compiler optimizations like the LLVM noalias attribute used on &mut T. Because the compiler ties the binding to the specific variant in the arm; if a variant binds by value, the inner data is moved into that binding. Ownership of the heap allocation transfers to the new owner; the original Box binding is invalidated. Mutation (let mut x) changes the value in place while keeping the type and binding; shadowing rebinds the name, possibly to a new type or value.

Question 48 Rust Ownership And Borrowing Explained

What is a "move" in Rust?

On the heap. The String struct itself (pointer, length, capacity) lives on the stack, and the buffer it points to is on the heap. Method resolution repeatedly dereferences the receiver with Deref until a method is found, so s.len() works for s: String via Deref<Target = str>. A transfer of ownership: assigning a value to another variable or passing it to a function moves the value, invalidating the source binding. To control variance and to ensure the borrow/drop checker considers the inner T even though it is not stored directly.

Question 49 Rust Ownership And Borrowing Explained

What is the orphan rule?

You can implement a foreign trait for a foreign type only if at least one of the trait or type is local to your crate. When matching a reference, bindings in the pattern automatically become references, so you don't have to write ref explicitly. Moving avoids double-free bugs and keeps the type system simple — for stack-allocated types that own heap data (like String), copying the pointer would leave two owners. Any number, but they cannot coexist with a mutable reference to the same value in the same scope.

Question 50 Rust Ownership And Borrowing Explained

What does `ref` do in a pattern?

It binds the matched value by reference, e.g. let Foo { ref x } = f; gives x: &T instead of moving x out of f. An enum owns exactly the data of one of its variants; moving the enum moves the data of that variant. It enables interior mutability for Copy types by replacing the value in place (cell.set(x)), avoiding the need for mutable references. A Box<T> is a smart pointer that owns a heap-allocated T; when the box is dropped, the inner T is dropped.

What is Arc<T>?

Can shadowing change a variable's type?

Which standard library function is called when a value goes out of scope?

How do you give ownership back from a function without moving?

What does the Deref trait do?

Why is PhantomData used in smart-pointer-like types?

What does [..], [a..], [..b], and [a..b] mean for ranges?

What is a "PhantomData<fn(T) -> T>" trick used for?

What is the elision rule for lifetimes in function signatures?

Does shadowing move or drop the old variable?

Can a type be Copy if it also implements Drop?

Why is "ownership of the iterator returned by vec.iter()" tied to the borrow?

What is "ownership of an array literal [1, 2, 3]"?

Where is a String's actual character data stored?

Does match create a new scope?