Merge branch 'mr/491-create-lab-for-module-lifetimes' into 'master'

Resolve "Create Lab for Module: Lifetimes"

Closes #491

See merge request feng/training/material!569

Author: frank-at-adacore

courses/rust_essentials/160_lifetimes/88-lifetimes.lab.rst

@@ -1,117 +1,17 @@
-============================
-Exercise: Protobuf Parsing
-============================
-
-------------------------------
-Protobuf Parsing Explanation
-------------------------------
-
-In this exercise, you will build a parser for the
-:url:`protobuf binary encoding <https://protobuf.dev/programming-guides/encoding/>`. Don't
-worry, it's simpler than it seems! This illustrates a common parsing
-pattern, passing slices of data. The underlying data itself is never
-copied.
-
-Fully parsing a protobuf message requires knowing the types of the
-fields, indexed by their field numbers. That is typically provided in a
-:rust:`proto` file. In this exercise, we'll encode that information into
-:rust:`match` statements in functions that get called for each field.
-
-We'll use the following proto:
-
-.. code:: proto
-
-   message PhoneNumber {
-     optional string number = 1;
-     optional string type = 2;
-   }
-
-   message Person {
-     optional string name = 1;
-     optional int32 id = 2;
-     repeated PhoneNumber phones = 3;
-   }
-
-
-------------------------------
-More Information on Protobuf
-------------------------------
-
-* Messages
-
-   A proto message is encoded as a series of fields, one after the next.
-   Each is implemented as a :dfn:`tag` followed by the value. The tag contains a
-   field number (e.g., :rust:`2` for the :rust:`id` field of a :rust:`Person` message)
-   and a wire type defining how the payload should be determined from the
-   byte stream. These are combined into a single integer, as decoded in
-   :rust:`unpack_tag` below.
-
-* Varint
-
-   Integers, including the tag, are represented with a variable-length
-   encoding called VARINT. Luckily, :rust:`parse_varint` is defined for you
-   below.
-
-* Wire Types
-
-   Proto defines several wire types, only two of which are used in this
-   exercise.
-
-   * The :rust:`Varint` wire type contains a single varint, and is used to encode proto values of type :rust:`int32` such as :rust:`Person.id`.
-
-   * The :rust:`Len` wire type contains a length expressed as a varint, followed by a payload of that number of bytes. This is used to encode proto values of type :rust:`string` such as :rust:`Person.name`. It is also used to encode proto values containing sub-messages such as :rust:`Person.phones`, where the payload contains an encoding of the sub-message.
-
-----------------
-Protobuf Types
-----------------
-
-.. container:: source_include 160_lifetimes/src/160_lifetimes.rs :start-after://ANCHOR-types :end-before://ANCHOR-helpers :code:rust
-
-------------------
-Protobuf Helpers
-------------------
-
-.. container:: source_include 160_lifetimes/src/160_lifetimes.rs :start-after://ANCHOR-helpers :end-before://ANCHOR-parse_field_solution :code:rust
+=====
+Lab
+=====
 
 ------------------
-Protobuf Problem
+Lab Instructions
 ------------------
 
-The given code also defines callbacks to handle :rust:`Person` and
-:rust:`PhoneNumber` fields, and to parse a message into a series of calls to
-those callbacks.
-
-What remains for you is to implement the :rust:`parse_field` function and
-the :rust:`ProtoMessage` trait for :rust:`Person` and :rust:`PhoneNumber`.
-
-.. code:: rust
-
-   /// Parse a field, returning the remaining bytes
-   fn parse_field(data: &[u8]) -> (Field, &[u8]) {
-       let (tag, remainder) = parse_varint(data);
-       let (field_num, wire_type) = unpack_tag(tag);
-       let (fieldvalue, remainder) = match wire_type {
-           _ => todo!("Based on the wire type, build a Field, consuming as many bytes as necessary.")
-       };
-       todo!("Return the field, and any un-consumed bytes.")
-   }
-
-.. container:: source_include 160_lifetimes/src/160_lifetimes.rs :start-after://ANCHOR-parse_message :end-before://ANCHOR-traits_solution :code:rust
-
-.. code:: rust
-
-   // TODO: Implement ProtoMessage for Person and PhoneNumber.
-
------------------------
-Protobuf Main Program
------------------------
+- Solve for compilation errors
 
-.. container:: source_include 160_lifetimes/src/160_lifetimes.rs :start-after://ANCHOR-main :code:rust
+- Follow the hints!
 
---------------------
-Protobuf Solutions
---------------------
+- Success is
 
-.. container:: source_include 160_lifetimes/src/160_lifetimes.rs :start-after://ANCHOR-parse_field_solution :end-before://ANCHOR-parse_message :code:rust
+    - Code that compiles
 
-.. container:: source_include 160_lifetimes/src/160_lifetimes.rs :start-after://ANCHOR-traits_solution :end-before://ANCHOR-main :code:rust
+    - ...and that follows any behavior indicated within the hints!

courses/rust_essentials/160_lifetimes/lab/answer/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "lab"
+name = "answer"
 version = "1.0.0"
 edition = "2024"
 

courses/rust_essentials/160_lifetimes/lab/answer/src/main.rs

@@ -1,3 +1,128 @@
+//! Lab (answer)
+//! Lifetimes
+//!
+//! Fix all the compile errors below by following the hints provided
+//!
+
+fn task_1() {
+    println!("Task 1 - Lifetime");
+    // Task 1 Goal
+    //   Ensure object lives as long as its reference
+    // Hint:
+    //   Object should be in same scope as reference (or higher)
+    let gold = 1000;
+    {
+        let treasure_map: &i32;
+        treasure_map = &gold;
+        println!("{treasure_map}");
+    }
+    println!("{gold}");
+}
+
+fn task_2() {
+    println!("Task 2 - Solving ambiguity");
+    // Task 2 Goal
+    //   Fix the function so that it can return the reference
+    //   of the longer string
+    // Hint:
+    //   Return value's lifetime is constrained by the shortest-lived string
+
+    fn choose<'a>(left: &'a str, right: &'a str) -> &'a str {
+        // Return reference to longer of 'left' or 'right'
+        if left.len() > right.len() {
+            left
+        } else {
+            right
+        }
+    }
+
+    let longer12: &str;
+    let longer23: &str;
+    let longer13: &str;
+    let input1 = String::from("medium");
+    {
+        let input2 = String::from("short");
+        {
+            let input3 = String::from("very long");
+            longer12 = choose(&input1, &input2);
+            longer23 = choose(&input2, &input3);
+            longer13 = choose(&input1, &input3);
+            println!("longer12 = {}", longer12);
+            println!("longer23 = {}", longer23);
+            println!("longer13 = {}", longer13);
+        }
+    }
+}
+
+fn task_3() {
+    println!("Task 3 - Lifetimes in structs");
+    // Task 3 Goal
+    //   Fix the function to allow it to return a reference from within a struct
+    // Hint:
+    //   Function needs to indicate where the borrowed data comes from
+    //   Struct needs to specify that the referenced element lasts as long as the struct
+
+    struct Owner {
+        name: String,
+    }
+    struct User<'a> {
+        name: &'a str,
+    }
+
+    fn find_user<'a>(owner: &'a Owner, _extra_data: &str) -> User<'a> {
+        User { name: &owner.name }
+    }
+
+    let my_owner = Owner {
+        name: String::from("Permanent"),
+    };
+    let result_user;
+    {
+        let short_lived_str = String::from("Temporary");
+        result_user = find_user(&my_owner, &short_lived_str);
+    }
+    println!("{}", result_user.name);
+}
+
+fn task_4() {
+    println!("Task 4 - Lifetimes for enums");
+    // Task 4 Goal
+    //   Fix the function to allow it to return a reference from within an enum variant
+    // Hint:
+    //   Function needs to indicate where the borrowed data comes from
+    //   Enum needs to specify that the referenced variant lasts as long as the enum
+    struct Owner {
+        name: String,
+    }
+
+    enum UserSession<'a> {
+        _Admin,
+        Guest(&'a str),
+    }
+
+    fn get_session<'a>(owner: &'a Owner, _extra: &str) -> UserSession<'a> {
+        UserSession::Guest(&owner.name)
+    }
+
+    let my_owner = Owner {
+        name: String::from("Permanent"),
+    };
+
+    let result_session;
+    {
+        let short_lived_str = String::from("Temporary");
+        result_session = get_session(&my_owner, &short_lived_str);
+    }
+
+    match result_session {
+        UserSession::Guest(name) => println!("Guest name: {}", name),
+        UserSession::_Admin => println!("Logged in as Admin"),
+    }
+}
+
 fn main() {
-    println!("TBD");
+    task_1();
+    task_2();
+    task_3();
+    task_4();
 }

courses/rust_essentials/160_lifetimes/lab/prompt/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "lab"
+name = "prompt"
 version = "1.0.0"
 edition = "2024"