Managing Borrowed Data with Lifetime Bounds

Rust's ownership system is powerful, ensuring memory safety at compile time. However, when working with references, the compiler needs to guarantee that these references never outlive the data they point to. Lifetime bounds are Rust's way of expressing these relationships between references. This challenge will test your understanding of how to correctly annotate and enforce these lifetime relationships.

Problem Description

You are tasked with implementing a system for managing "documents" and "references" to those documents. A Document will contain some data, and a Reference will hold a reference to a Document along with some additional metadata. The critical requirement is to ensure that a Reference can never outlive the Document it points to. You will achieve this by using explicit lifetime annotations.

What needs to be achieved:

1. Define a Document struct that holds a String representing its content.
2. Define a Reference struct that holds a reference to a Document and a String for its metadata.
3. Implement methods for creating Document and Reference instances.
4. Crucially, ensure that the lifetime of the Reference's borrowed Document is correctly constrained by the lifetime of the Document itself.
5. Demonstrate that a Reference cannot be created if the Document it points to would go out of scope before the Reference.

Key requirements:

• Use explicit lifetime annotations ('a, 'b, etc.) on structs and their fields where necessary to represent borrowing.
• The Reference struct must borrow from the Document.
• The compiler should prevent the creation of a Reference that might outlive its Document.

Expected behavior:

• You should be able to create a Document and then a Reference that points to it, as long as both exist within the same scope or the Document outlives the Reference.
• If you attempt to create a Reference that would point to a Document that is about to go out of scope, the Rust compiler should raise a lifetime error.

Important edge cases to consider:

• What happens when a Reference is created in a scope that is shorter than the Document's scope?
• How do you handle cases where a Document might be moved or dropped while a Reference still exists? (Though the compiler's lifetime checks should prevent this).

Examples

Example 1:

struct Document {
    content: String,
}

struct Reference<'a> {
    doc: &'a Document,
    metadata: String,
}

impl Document {
    fn new(content: String) -> Self {
        Document { content }
    }
}

impl<'a> Reference<'a> {
    fn new(doc: &'a Document, metadata: String) -> Self {
        Reference { doc, metadata }
    }
}

fn main() {
    let doc = Document::new("This is the document content.".to_string());
    let ref_to_doc = Reference::new(&doc, "Key metadata".to_string());

    println!("Document content: {}", ref_to_doc.doc.content);
    println!("Reference metadata: {}", ref_to_doc.metadata);
}

Output:

Document content: This is the document content.
Reference metadata: Key metadata

Explanation: A Document is created, and then a Reference is created pointing to it. The lifetime of ref_to_doc is implicitly tied to the lifetime of doc because Reference is annotated with 'a. The compiler ensures that ref_to_doc cannot outlive doc.

Example 2: (Illustrating a compile-time error)

struct Document {
    content: String,
}

struct Reference<'a> {
    doc: &'a Document,
    metadata: String,
}

impl Document {
    fn new(content: String) -> Self {
        Document { content }
    }
}

impl<'a> Reference<'a> {
    fn new(doc: &'a Document, metadata: String) -> Self {
        Reference { doc, metadata }
    }
}

fn main() {
    let ref_to_doc; // Declare reference outside the scope of doc

    {
        let doc = Document::new("Temporary document.".to_string());
        // Attempting to create a reference that might outlive the document
        // The compiler will error here because 'doc' goes out of scope before
        // 'ref_to_doc' is guaranteed to go out of scope.
        // Uncommenting the line below will result in a compile-time error.
        // ref_to_doc = Reference::new(&doc, "Metadata for temp doc".to_string());
    }

    // If the above line were allowed, this would be a dangling pointer.
    // println!("Attempting to access metadata: {}", ref_to_doc.metadata);
}

Expected Behavior: This code will not compile. The Rust compiler will report a lifetime error, indicating that doc does not live long enough to be borrowed by ref_to_doc. This demonstrates that lifetime bounds correctly prevent the creation of invalid references.

Constraints

• The Document struct must store its content as a String.
• The Reference struct must store its metadata as a String.
• All borrowed references within structs must be explicitly managed with lifetime annotations.
• The provided main function signatures in the examples should be used as a starting point for your implementation.

Notes

• Think about the 'a in struct Reference<'a>. What does it signify?
• Consider the relationship between the lifetime of the Reference itself and the lifetime of the Document it borrows.
• The compiler's error messages are your best friend when working with lifetimes. Pay close attention to them.
• You are not expected to implement complex drop logic; the focus is purely on lifetime annotation and compile-time safety.