From 1ef8dacaf69e3ad1418355eeea128c00f09bdcb3 Mon Sep 17 00:00:00 2001
From: jayber <james.a.bromley@gmail.com>
Date: Fri, 15 Jul 2022 14:01:32 +0200
Subject: [PATCH] feat: add lifetimes exercises
---
exercises/lifetimes/README.md | 17 +++++++++++++++++
exercises/lifetimes/lifetimes1.rs | 26 ++++++++++++++++++++++++++
exercises/lifetimes/lifetimes2.rs | 27 +++++++++++++++++++++++++++
exercises/lifetimes/lifetimes3.rs | 20 ++++++++++++++++++++
info.toml | 24 ++++++++++++++++++++++++
5 files changed, 114 insertions(+)
create mode 100644 exercises/lifetimes/README.md
create mode 100644 exercises/lifetimes/lifetimes1.rs
create mode 100644 exercises/lifetimes/lifetimes2.rs
create mode 100644 exercises/lifetimes/lifetimes3.rs
diff --git a/exercises/lifetimes/README.md b/exercises/lifetimes/README.md
new file mode 100644
index 0000000..72befb3
--- /dev/null
+++ b/exercises/lifetimes/README.md
@@ -0,0 +1,17 @@
+# Lifetimes
+
+Lifetimes tell the compiler how to check whether references live long
+enough to be valid in any given situation. For example lifetimes say
+"make sure parameter 'a' lives as long as parameter 'b' so that the return
+value is valid".
+
+They are only necessary on borrows, i.e. references,
+since copied parameters or moves are owned in their scope and cannot
+be referenced outside. Lifetimes mean that calling code of e.g. functions
+can be checked to make sure their arguments are valid. Lifetimes are
+restrictive of their callers.
+
+## Further information
+
+- [Validating References with Lifetimes](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html)
+- [Lifetimes (in Rust By Example)](https://doc.rust-lang.org/stable/rust-by-example/scope/lifetime.html)
diff --git a/exercises/lifetimes/lifetimes1.rs b/exercises/lifetimes/lifetimes1.rs
new file mode 100644
index 0000000..58e995c
--- /dev/null
+++ b/exercises/lifetimes/lifetimes1.rs
@@ -0,0 +1,26 @@
+// lifetimes1.rs
+//
+// The Rust compiler needs to know how to check whether supplied references are
+// valid, so that it can let the programmer know if a reference is at risk
+// of going out of scope before it is used. Remember, references are borrows
+// and do not own their own data. What if their owner goes out of scope?
+//
+// Execute `rustlings hint lifetimes1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn longest(x: &str, y: &str) -> &str {
+ if x.len() > y.len() {
+ x
+ } else {
+ y
+ }
+}
+
+fn main() {
+ let string1 = String::from("abcd");
+ let string2 = "xyz";
+
+ let result = longest(string1.as_str(), string2);
+ println!("The longest string is {}", result);
+}
diff --git a/exercises/lifetimes/lifetimes2.rs b/exercises/lifetimes/lifetimes2.rs
new file mode 100644
index 0000000..c73a28a
--- /dev/null
+++ b/exercises/lifetimes/lifetimes2.rs
@@ -0,0 +1,27 @@
+// lifetimes2.rs
+//
+// So if the compiler is just validating the references passed
+// to the annotated parameters and the return type, what do
+// we need to change?
+//
+// Execute `rustlings hint lifetimes2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
+ if x.len() > y.len() {
+ x
+ } else {
+ y
+ }
+}
+
+fn main() {
+ let string1 = String::from("long string is long");
+ let result;
+ {
+ let string2 = String::from("xyz");
+ result = longest(string1.as_str(), string2.as_str());
+ }
+ println!("The longest string is {}", result);
+}
diff --git a/exercises/lifetimes/lifetimes3.rs b/exercises/lifetimes/lifetimes3.rs
new file mode 100644
index 0000000..ea48370
--- /dev/null
+++ b/exercises/lifetimes/lifetimes3.rs
@@ -0,0 +1,20 @@
+// lifetimes3.rs
+//
+// Lifetimes are also needed when structs hold references.
+//
+// Execute `rustlings hint lifetimes3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+struct Book {
+ author: &str,
+ title: &str,
+}
+
+fn main() {
+ let name = String::from("Jill Smith");
+ let title = String::from("Fish Flying");
+ let book = Book { author: &name, title: &title };
+
+ println!("{} by {}", book.title, book.author);
+}
diff --git a/info.toml b/info.toml
index 8871c15..bc2a91c 100644
--- a/info.toml
+++ b/info.toml
@@ -746,6 +746,30 @@ You can call a function right where you're passing arguments to `assert!` -- so
something like `assert!(having_fun())`. If you want to check that you indeed get false, you
can negate the result of what you're doing using `!`, like `assert!(!having_fun())`."""
+# LIFETIMES
+
+[[exercises]]
+name = "lifetimes1"
+path = "exercises/lifetimes/lifetimes1.rs"
+mode = "compile"
+hint = """
+Let the compiler guide you. Also take a look at the book if you need help:
+https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html"""
+
+[[exercises]]
+name = "lifetimes2"
+path = "exercises/lifetimes/lifetimes2.rs"
+mode = "compile"
+hint = """
+What is the compiler checking? How could you change how long an owned variable lives?"""
+
+[[exercises]]
+name = "lifetimes3"
+path = "exercises/lifetimes/lifetimes3.rs"
+mode = "compile"
+hint = """
+If you use a lifetime annotation in a struct's fields, where else does it need to be added?"""
+
# STANDARD LIBRARY TYPES
[[exercises]]