2020-08-27
1731
#rust
Thomas Heartman
23920
Aug 27, 2020 ⋅ 6 min read

Understanding lifetimes in Rust

Thomas Heartman Developer, speaker, musician, and fitness instructor.

Recent posts:

Designing For Instant Feedback- The Doherty Threshold In UX

Designing for instant feedback: The Doherty Threshold in UX

The Doherty Threshold suggests that when feedback occurs within this timeframe, users feel more in control and remain engaged.

Chidera Nwankwagu
Mar 26, 2025 ⋅ 4 min read
what is pair programming

What is pair programming – and should you try it?

Learn what pair programming is, its benefits, and how real-world implementation can improve your software development process.

Andrew Evans
Mar 26, 2025 ⋅ 6 min read
docker exec command

How to use docker exec to interact with running containers

Read up on how to interact with running containers using the docker exec command, and discover the difference between exec and attach.

Paul Akinyemi
Mar 25, 2025 ⋅ 4 min read
array filter method javascript

How to use the array filter() method in JavaScript

Learn about the array filter() method, from its basic syntax and use cases to more advanced techniques like chaining with map() and reduce().

Abiola Farounbi
Mar 24, 2025 ⋅ 5 min read
View all posts

2 Replies to "Understanding lifetimes in Rust"

  1. You write: “Lifetimes are what the Rust compiler uses to keep track of how long references are valid for.” But what about keeping track of which objects are borrowed? If I have a function f with signature fn f(x: &’a i32) -> &’a i32; and I do let x = 0; let y = f(&x); then rust borrow checker will consider y to be borrowing x . I don’t get this.

  2. Hey! Thanks for the question. Let me try and answer it for you.

    > How does the compiler keep track of which objects are borrowed?

    Any reference is a borrow. Whenever you have a value that’s not the owned instance, you have a borrow. In other words, keeping track of borrows is the same as keeping track of references. Declaring references (and lifetimes) in function signatures helps the compiler get the information it needs to keep track of borrows.

    > Why is `y` borrowing `x`?

    In your example, the function `f` takes a reference and returns the same reference. You then assign `y` to that reference. In other words, `y` is an `&i32`, while x is an `i32`. Because every reference is a borrow, ‘`y` borrows `x`’.

    Does that answer your questions?

Leave a Reply