{"@context":"https://schema.org","@type":"FAQPage","mainEntity":[{"@type":"Question","name":"What is a Higher-Ranked Trait Bound (HRTB) in Rust?","acceptedAnswer":{"@type":"Answer","text":"A Higher-Ranked Trait Bound (HRTB) allows specifying that a function or trait must work for all possible lifetimes, not just a specific one. The for<'a> syntax indicates that the bound must be satisfied for any lifetime 'a chosen by the caller. This feature is essential for closures and callbacks that need to accept references with varying lifetimes."}},{"@type":"Question","name":"What is the difference between fn foo<'a>(f: impl Fn(&'a str)) and fn foo(f: impl for<'a> Fn(&'a str))?","acceptedAnswer":{"@type":"Answer","text":"With fn foo<'a>, the lifetime 'a is fixed by the caller at call time and remains the same throughout execution. With for<'a>, the closure must work for any lifetime, allowing it to be called multiple times with references of different lifetimes. This distinction is crucial for APIs that call a closure multiple times with different temporary references."}},{"@type":"Question","name":"What is lifetime subtyping in Rust and what does 'a: 'b mean?","acceptedAnswer":{"@type":"Answer","text":"Lifetime subtyping establishes a subtyping relationship between lifetimes. The notation 'a: 'b means 'a lives at least as long as 'b, so 'a is a subtype of 'b. A reference with a longer lifetime can be used where a shorter lifetime is expected. This relationship is covariant for immutable references, allowing a reference with a longer lifetime to be passed where a shorter one would suffice."}},{"@type":"Question","name":"What is variance in Rust and how does it affect generic types?","acceptedAnswer":{"@type":"Answer","text":"Variance describes how the subtyping relationship of a type propagates through generic type constructors. A type is covariant if T<'long> is a subtype of T<'short> when 'long: 'short. It is contravariant if the relationship is reversed, and invariant if no subtyping relationship exists. In Rust, immutable references are covariant, mutable references are invariant, and function parameters are contravariant."}},{"@type":"Question","name":"Why is &mut T invariant with respect to T while &T is covariant?","acceptedAnswer":{"@type":"Answer","text":"A mutable reference &mut T is invariant because it allows both reading and writing. If it were covariant, one could write a value of an incorrect type. If it were contravariant, one could read a value as an incorrect type. Invariance ensures the pointed type matches exactly what is expected. An immutable reference &T is covariant because it only allows reading, making it safe to accept a subtype."}},{"@type":"Question","name":"What is the main characteristic of the 'static lifetime in Rust?","acceptedAnswer":{"@type":"Answer","text":"The 'static lifetime indicates that a reference can live for the entire duration of program execution. String literals automatically have the 'static lifetime because they are embedded in the binary. Owned types like String or Vec also satisfy the T: 'static bound because they contain no references with limited lifetimes. Be careful not to confuse 'static with static memory allocation."}},{"@type":"Question","name":"What is the difference between T: 'static and &'static T?","acceptedAnswer":{"@type":"Answer","text":"The bound T: 'static means type T contains no references with a non-'static lifetime, which includes all owned types like String, Vec, or i32. The type &'static T is a reference that must live for the entire program duration. A String satisfies T: 'static but is not a &'static str. This distinction matters for threads and 'static closures that require T: 'static, not necessarily 'static references."}},{"@type":"Question","name":"What is NLL (Non-Lexical Lifetimes) in Rust and what problem does it solve?","acceptedAnswer":{"@type":"Answer","text":"NLL (Non-Lexical Lifetimes) is a borrow checker improvement introduced in Rust 2018. Before NLL, lifetimes were tied to lexical scopes, causing valid code to be rejected. With NLL, the borrow checker analyzes the actual code flow and ends a borrow as soon as the reference is no longer used, not at scope end. This allows writing more natural code without artificial temporary variables."}},{"@type":"Question","name":"When should you use an HRTB (for<'a>) rather than an explicit generic lifetime parameter?","acceptedAnswer":{"@type":"Answer","text":"An HRTB is needed when a closure or function must accept references with different lifetimes at each call. For example, a function iterating over a collection and calling a closure for each element with a temporary reference. Without HRTB, the lifetime would be fixed at the first call. HRTBs are common with Fn, FnMut, FnOnce traits and trait implementations for functions."}},{"@type":"Question","name":"How do you declare a trait with an HRTB for a method that takes a reference?","acceptedAnswer":{"@type":"Answer","text":"To declare a trait with HRTB, the syntax uses for<'a> in the bound. For example, for a Parser trait with a parse method taking &'a str, the bound would be T: for<'a> Parser<'a>. This means the implementation must work for all possible lifetimes of the input. This technique is used in libraries like serde for deserializing data with varying lifetimes."}},{"@type":"Question","name":"What is covariance and in which cases does it apply to references in Rust?","acceptedAnswer":{"@type":"Answer","text":"Covariance means that if 'long outlives 'short ('long: 'short), then &'long T is a subtype of &'short T. This applies to immutable references because it is always safe to treat a longer-lived reference as a shorter-lived one. Types like Vec, Box, and Option are also covariant with respect to T. This property allows greater flexibility when passing references."}},{"@type":"Question","name":"What is contravariance and where does it appear in Rust?","acceptedAnswer":{"@type":"Answer","text":"Contravariance is the opposite of covariance: if 'long: 'short, then fn(&'short T) is a subtype of fn(&'long T). In Rust, contravariance appears in function argument positions. A function that can accept any short reference can also accept a long reference. PhantomData is used to make a type contravariant with respect to T when needed."}},{"@type":"Question","name":"What is the role of PhantomData in variance management in Rust?","acceptedAnswer":{"@type":"Answer","text":"PhantomData is a zero-sized type that tells the compiler a type is logically related to T without actually containing T. It affects the enclosing type's variance. PhantomData makes the type covariant with respect to T, PhantomData makes it contravariant, and PhantomData<*mut T> or PhantomData T> makes it invariant. This is essential for unsafe implementations and low-level abstractions."}},{"@type":"Question","name":"How did NLL improve borrow handling in conditions and loops?","acceptedAnswer":{"@type":"Answer","text":"Before NLL, a borrow in an if branch extended to the end of the enclosing block even if the branch was not executed. With NLL, the borrow checker analyzes the control flow graph and understands that borrows in mutually exclusive branches do not overlap. Similarly for loops, a borrow in the body no longer prevents mutations after the loop if the reference is no longer used."}},{"@type":"Question","name":"How do you use a lifetime bound on a generic type, like T: 'a?","acceptedAnswer":{"@type":"Answer","text":"The bound T: 'a means all references contained in T must live at least as long as 'a. This is needed when a struct stores both a generic type T and a reference with lifetime 'a. If T contains references shorter than 'a, this could create dangling references. This bound ensures T won't invalidate the struct's 'a references."}},{"@type":"Question","name":"Why are Cell and RefCell invariant with respect to T?","acceptedAnswer":{"@type":"Answer","text":"Cell and RefCell allow interior mutability, meaning they can modify their contents even through a shared reference. If Cell<&'long T> could be converted to Cell<&'short T>, one could write a short reference and read it back as a long reference, creating a dangling reference. Invariance prevents this dangerous conversion and ensures type soundness."}},{"@type":"Question","name":"How does lifetime elision work with HRTBs in Fn traits?","acceptedAnswer":{"@type":"Answer","text":"When writing Fn(&str) -> &str without annotations, Rust automatically applies an implicit HRTB: for<'a> Fn(&'a str) -> &'a str. This means the closure must work for all possible input lifetimes, and the output lifetime is tied to the input. This elision makes code more concise while preserving correct semantics for closures working with references."}},{"@type":"Question","name":"What problem does lifetime subtyping solve when passing references to functions?","acceptedAnswer":{"@type":"Answer","text":"Lifetime subtyping allows passing a reference with a longer lifetime to a function expecting a shorter lifetime. Without subtyping, it would be impossible to pass a 'static reference to a function expecting 'a. This flexibility is essential for language ergonomics, as string literals ('static) can be used wherever a &str with any lifetime is expected."}},{"@type":"Question","name":"How do HRTBs interact with trait objects (dyn Trait)?","acceptedAnswer":{"@type":"Answer","text":"Trait objects with HRTBs require special attention. For example, Box Fn(&'a str)> creates a trait object for a closure accepting references of any lifetime. Without the explicit HRTB, the lifetime would be fixed at trait object creation time. HRTBs are essential for stored callbacks that must be called with references of varying lifetimes."}},{"@type":"Question","name":"What is the impact of variance on generic collections like Vec?","acceptedAnswer":{"@type":"Answer","text":"Vec is covariant with respect to T, meaning Vec<&'long str> is a subtype of Vec<&'short str> when 'long: 'short. This works because Vec does not allow inserting new elements through a shared reference. If Vec were invariant, it would be impossible to pass a Vec of long references to a function expecting shorter references, significantly reducing flexibility."}}]}