lifetimes

Author: dumindu

content/en/docs/c3.lifetimes.md

@@ -3,41 +3,53 @@ title: Lifetimes
 slug: lifetimes
 ---
 
-> [!caution]
-> This needs a refresh!
+> [!recap]
+> - Ownership: Each piece of data has a single owner, and data is only scoped to its owner (unless it is borrowed).
+> - In Rust, borrowing is the act of creating a reference to a value without copying the data and without taking ownership (move). While a reference exists, the original owner retains ownership, but its access to the data is restricted (or completely locked if `&mut`) until that reference’s last use.
+> - Liveness:
+>   - Owned values (`T`) are dropped at the end of their scope (unless moved early).
+>   - References (`&T`, `&mut T`) effectively end/ expire at their last use. This is known as Non-Lexical Lifetimes (NLL).
+> - Lifetimes are Rust's way of guaranteeing that a reference is valid within a discrete region of code at compile time.
 
-When we are dealing with references, we have to make sure that the referencing data stay alive until we stop using the references.
+## Lifetimes
 
-Think,
+- A lifetime is a construct the Rust compiler's borrow checker uses to track how long references remain valid and every reference in Rust has a lifetime.
+- However, most local lifetimes are implicitly figured out by the compiler through a mechanism called lifetime elision.
+- The primary purpose of lifetimes is to prevent dangling references, ensuring data is never dropped while a pointer still looks at it.
 
-- We have a variable binding, `a`.
-- We are referencing the value of `a`, from another variable binding `x`.
-  
-We have to make sure that `a` lives until we stop using `x`.
+Annotating a lifetime does not extend the lifespan of an actual value. It is simply a contract that tells the compiler, "The lifespan of this reference is guaranteed to be tied to the lifespan of this data."
 
-> [!recap]
-> **Memory management** is a form of resource management applied to computer memory. Up until the mid-1990s, the majority of 
-> programming languages used Manual Memory Management which requires the programmer to give manual instructions to 
-> identify and deallocate unused objects/ garbage. Around 1959 John McCarthy invented Garbage collection\(GC\), 
-> a form of Automatic Memory Management\(AMM\). It determines what memory is no longer used and frees it automatically instead
-> of relying on the programmer. However, Objective-C and Swift provide similar functionality through Automatic Reference Counting\(ARC\).
+Lifetimes are declared with a single leading apostrophe `'`. By convention, lowercase letters are used starting from `'a`, moving alphabetically if multiple lifetimes are required.
 
+```rust
+fn main() {
+    let a = "A";
 
-## What is Lifetime?
+    take_str(a);
+    take_str_elided(a);
+}
 
-In Rust,
+fn take_str<'a>(x: &'a str) {
+    println!("{x}");
+}
 
-* A resource can only have **one owner** at a time. When it goes **out of the scope**, Rust removes it from the Memory.
-* When we want to reuse the same resource, we are **referencing** it/ **borrowing** its content.
-* When dealing with **references**, we have to specify **lifetime annotations** to provide instructions for the **compiler** to set **how long** those referenced resources **should be alive**.
-* ⭐ But because of lifetime annotations make the **code more verbose**, in order to make **common patterns** more ergonomic, Rust allows lifetimes to be **elided/omitted** in `fn` definitions. In this case, the compiler assigns lifetime annotations **implicitly**.
+fn take_str_elided(x: &str) {
+    println!("{x}");
+}
+```
 
-Lifetime annotations are **checked at compile-time**. The compiler checks when data is used for the first and the last times.
+`'static` is a special lifetime that indicating the reference can live for the entire duration of the program execution.
 
-> * Unlike C and C++, **usually**, Rust doesn’t require explicitly dropping values at all.
-> * Unlike GC, Rust doesn’t place deallocation calls where the data is no longer referenced.
-> * Rust places deallocation calls where the data is about to go out of the scope and then enforces that no references to that resource exist after that point.
+```rust
+fn main() {
+    let a = "A";
+    take_str(a);
+}
 
+fn take_str(x: &'static str) {
+    println!("{x}");
+}
+```
 
 ## Usage
 

docs/docs/index.xml

@@ -468,30 +468,40 @@ __ <a href="https://wiki.haskell.org/Combinator" target="_blank" >wiki.has
 		&lt;p&gt;This can be any form of &lt;code&gt;self&lt;/code&gt;, &lt;code&gt;&amp;amp;self&lt;/code&gt;, &lt;code&gt;&amp;amp;mut self&lt;/code&gt;, &lt;code&gt;self: Box&amp;lt;Self&amp;gt;&lt;/code&gt;, &lt;code&gt;self: Pin&amp;lt;&amp;amp;mut Self&amp;gt;&lt;/code&gt;, etc.&lt;/p&gt;</description></item><item><title>Installation</title><link>https://learning-rust.github.io/docs/installation/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/installation/</guid><description>&lt;h2 id="rustup"&gt;Rustup&lt;/h2&gt;
 &lt;p&gt;There are many ways to install Rust on your system. For the moment the official way to install Rust is using &lt;a href="https://rustup.rs/" target="_blank" &gt;Rustup&lt;/a&gt;.&lt;/p&gt;
 &lt;p&gt;&lt;a href="https://rust-lang.github.io/rustup/index.html" target="_blank" &gt;📖&lt;/a&gt; Rustup installs The Rust Programming Language from the official release channels, enabling you to easily switch between &lt;strong&gt;stable, beta, and nightly&lt;/strong&gt; compilers and keep them updated. It also makes cross-compiling simpler with binary builds of the standard library for common platforms.&lt;/p&gt;
-&lt;p&gt;&lt;a href="https://rust-lang.github.io/rustup/installation/index.html" target="_blank" &gt;📖&lt;/a&gt; Rustup installs &lt;code&gt;rustc&lt;/code&gt;, &lt;code&gt;cargo&lt;/code&gt;, &lt;code&gt;rustup&lt;/code&gt; and other standard tools to &lt;strong&gt;Cargo&amp;rsquo;s &lt;code&gt;bin&lt;/code&gt; directory&lt;/strong&gt;. On Unix it is located at &lt;code&gt;$HOME/.cargo/bin&lt;/code&gt; and on Windows at &lt;code&gt;%USERPROFILE%\.cargo\bin&lt;/code&gt;. This is the same directory that &lt;code&gt;cargo install&lt;/code&gt; will install Rust programs and Cargo plugins.&lt;/p&gt;</description></item><item><title>Lifetimes</title><link>https://learning-rust.github.io/docs/lifetimes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/lifetimes/</guid><description>&lt;div class="alert alert-caution"&gt;
+&lt;p&gt;&lt;a href="https://rust-lang.github.io/rustup/installation/index.html" target="_blank" &gt;📖&lt;/a&gt; Rustup installs &lt;code&gt;rustc&lt;/code&gt;, &lt;code&gt;cargo&lt;/code&gt;, &lt;code&gt;rustup&lt;/code&gt; and other standard tools to &lt;strong&gt;Cargo&amp;rsquo;s &lt;code&gt;bin&lt;/code&gt; directory&lt;/strong&gt;. On Unix it is located at &lt;code&gt;$HOME/.cargo/bin&lt;/code&gt; and on Windows at &lt;code&gt;%USERPROFILE%\.cargo\bin&lt;/code&gt;. This is the same directory that &lt;code&gt;cargo install&lt;/code&gt; will install Rust programs and Cargo plugins.&lt;/p&gt;</description></item><item><title>Lifetimes</title><link>https://learning-rust.github.io/docs/lifetimes/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/lifetimes/</guid><description>&lt;div class="alert alert-recap"&gt;
 	&lt;div class="alert-header"&gt;
 
 
 
-	&lt;svg xmlns="http://www.w3.org/2000/svg" height="20px" viewBox="0 -960 960 960" width="20px"&gt;&lt;path d="M480-300q15 0 25.5-10.5T516-336q0-15-10.5-25.5T480-372q-15 0-25.5 10.5T444-336q0 15 10.5 25.5T480-300Zm25.5-142.5Q516-453 516-468v-168q0-15-10.5-25.5T480-672q-15 0-25.5 10.5T444-636v168q0 15 10.5 25.5T480-432q15 0 25.5-10.5ZM371-144q-14 0-27-5t-24-16L165-321q-10-10-15.5-23.5T144-372v-217q0-14 5-27t16-24l155-155q11-11 24-16t27-5h218q14 0 27 5t24 16l155 155q11 11 16 24t5 27v218q0 14-5 27t-16 24L639-165q-10 10-23.5 15.5T588-144H371Zm0-72h218l155-155v-218L588-744H371L216-589v218l155 155Zm109-264Z"/&gt;&lt;/svg&gt;
+	&lt;svg xmlns="http://www.w3.org/2000/svg" height="20px" viewBox="0 -960 960 960" width="20px"&gt;&lt;path d="m687-273-78-160 95-95-79.77-79.77v-112.46H511.77L432-800l-79.77 79.77H239.77v112.46L160-528l79.77 79.77v112.46h112.46L432-256l95-95 160 78Zm104 104q-8 8-19 10.5t-22-3.5L541-264l-84 84q-10.64 11-24.82 11T407-180l-84.26-84H204q-15.3 0-25.65-10.35Q168-284.7 168-300v-118.74L84-503q-11-10.64-11-24.82T84-553l84-84.26V-756q0-15.3 10.35-25.65Q188.7-792 204-792h118.74L407-876q10.64-11 24.82-11T457-876l84.26 84H660q15.3 0 25.65 10.35Q696-771.3 696-756v118.74L780-553q11 10.64 11 24.82T780-503l-84 84 102 209q6 11 3.5 22T791-169ZM432-528Z"/&gt;&lt;/svg&gt;
 
 
 		&lt;span&gt;
 
-			Caution
+			Recap
 
 		&lt;/span&gt;
 	&lt;/div&gt;
 	&lt;div class="alert-body"&gt;
-		&lt;p&gt;This needs a refresh!&lt;/p&gt;
+		&lt;ul&gt;
+&lt;li&gt;Ownership: Each piece of data has a single owner, and data is only scoped to its owner (unless it is borrowed).&lt;/li&gt;
+&lt;li&gt;In Rust, borrowing is the act of creating a reference to a value without copying the data and without taking ownership (move). While a reference exists, the original owner retains ownership, but its access to the data is restricted (or completely locked if &lt;code&gt;&amp;amp;mut&lt;/code&gt;) until that reference’s last use.&lt;/li&gt;
+&lt;li&gt;Liveness:
+&lt;ul&gt;
+&lt;li&gt;Owned values (&lt;code&gt;T&lt;/code&gt;) are dropped at the end of their scope (unless moved early).&lt;/li&gt;
+&lt;li&gt;References (&lt;code&gt;&amp;amp;T&lt;/code&gt;, &lt;code&gt;&amp;amp;mut T&lt;/code&gt;) effectively end/ expire at their last use. This is known as Non-Lexical Lifetimes (NLL).&lt;/li&gt;
+&lt;/ul&gt;
+&lt;/li&gt;
+&lt;li&gt;Lifetimes are Rust&amp;rsquo;s way of guaranteeing that a reference is valid within a discrete region of code at compile time.&lt;/li&gt;
+&lt;/ul&gt;
 	&lt;/div&gt;
-&lt;/div&gt;&lt;p&gt;When we are dealing with references, we have to make sure that the referencing data stay alive until we stop using the references.&lt;/p&gt;
-&lt;p&gt;Think,&lt;/p&gt;
+&lt;/div&gt;&lt;h2 id="lifetimes"&gt;Lifetimes&lt;/h2&gt;
 &lt;ul&gt;
-&lt;li&gt;We have a variable binding, &lt;code&gt;a&lt;/code&gt;.&lt;/li&gt;
-&lt;li&gt;We are referencing the value of &lt;code&gt;a&lt;/code&gt;, from another variable binding &lt;code&gt;x&lt;/code&gt;.&lt;/li&gt;
+&lt;li&gt;A lifetime is a construct the Rust compiler&amp;rsquo;s borrow checker uses to track how long references remain valid and every reference in Rust has a lifetime.&lt;/li&gt;
+&lt;li&gt;However, most local lifetimes are implicitly figured out by the compiler through a mechanism called lifetime elision.&lt;/li&gt;
+&lt;li&gt;The primary purpose of lifetimes is to prevent dangling references, ensuring data is never dropped while a pointer still looks at it.&lt;/li&gt;
 &lt;/ul&gt;
-&lt;p&gt;We have to make sure that &lt;code&gt;a&lt;/code&gt; lives until we stop using &lt;code&gt;x&lt;/code&gt;.&lt;/p&gt;</description></item><item><title>Modules</title><link>https://learning-rust.github.io/docs/modules/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/modules/</guid><description>&lt;div class="alert alert-caution"&gt;
+&lt;p&gt;Annotating a lifetime does not extend the lifespan of an actual value. It is simply a contract that tells the compiler, &amp;ldquo;The lifespan of this reference is guaranteed to be tied to the lifespan of this data.&amp;rdquo;&lt;/p&gt;</description></item><item><title>Modules</title><link>https://learning-rust.github.io/docs/modules/</link><pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate><guid>https://learning-rust.github.io/docs/modules/</guid><description>&lt;div class="alert alert-caution"&gt;
 	&lt;div class="alert-header"&gt;