From 286e803d40a7eead0afb34ab1b5c6b3193d903bb Mon Sep 17 00:00:00 2001 From: junderw Date: Mon, 2 Sep 2024 23:26:39 +0900 Subject: [PATCH 1/3] WIP Closures1 --- exercises/18_closures/README.md | 25 ++++++++++++ exercises/18_closures/closures1.rs | 64 ++++++++++++++++++++++++++++++ exercises/README.md | 1 + rustlings-macros/info.toml | 11 +++++ 4 files changed, 101 insertions(+) create mode 100644 exercises/18_closures/README.md create mode 100644 exercises/18_closures/closures1.rs diff --git a/exercises/18_closures/README.md b/exercises/18_closures/README.md new file mode 100644 index 0000000000..52bac3f288 --- /dev/null +++ b/exercises/18_closures/README.md @@ -0,0 +1,25 @@ +# Closures + +Closures in Rust are anonymous functions that can capture variables from their surrounding environment. They are similar to lambda expressions or anonymous functions in other languages like Python or JavaScript, but with a few key differences that stem from Rust's ownership system and its focus on safety and performance. + +## How Closures Work in Rust + +In Rust, closures are defined using the pipe syntax (ie. `|x: String|`) to enclose their parameters and are generally more flexible than functions because they can capture variables from their environment in three different ways: + +By Shared Reference (`&T`): Borrowing values from the environment without taking ownership. +By Exclusive Reference (`&mut T`): Mutably borrowing values, allowing them to be modified. +By Value (`T`): Taking ownership of the values, which can be moved into the closure. +This flexibility allows closures to be used in a variety of contexts, such as iterators, where they can efficiently process data streams without the overhead of function calls. Rust's closures can also implement one of the three `Fn`, `FnMut`, or `FnOnce` traits, depending on how they capture their environment, which makes them highly adaptable for various use cases. + +## Comparison to Other Languages + +Unlike higher-level languages where closures often simply reference variables from their enclosing scope, Rust's closures need to conform to strict ownership and borrowing rules. This ensures memory safety but also introduces complexities not found in more dynamic languages. For example, deciding whether a closure should move or borrow variables can be non-trivial, especially when dealing with mutable or non-`Copy` types. + +## Common Challenges + +One of the challenges with closures in Rust is understanding how they capture variables and the implications for the borrow checker. For instance, if a closure moves a variable, that variable is no longer accessible after the closure is called, which can lead to borrow checker errors that might confuse newcomers. Additionally, because closures in Rust can sometimes have complex types (especially when capturing environment variables), they often require type annotations or explicit trait bounds when used in generic contexts. + +## Further information + +- [The Rust Book](https://doc.rust-lang.org/stable/book/ch13-01-closures.html) +- [Rust By Example](https://doc.rust-lang.org/rust-by-example/fn/closures.html) diff --git a/exercises/18_closures/closures1.rs b/exercises/18_closures/closures1.rs new file mode 100644 index 0000000000..91396208e7 --- /dev/null +++ b/exercises/18_closures/closures1.rs @@ -0,0 +1,64 @@ +// closures1.rs +// +// "Why do we even need closures?" is a question that gets asked from time to time. +// While it's true that most things that closures can do can also be done with +// regular old structs and enums, closures can make things a lot more clear with a lot +// less clutter compared to structs. +// +// Below is a good example of how one could implement a capturing closure using structs, +// and how closures simplifies this greatly. +// +// Execute `rustlings hint closures1` or use the `hint` watch subcommand for a hint. + +// I AM NOT DONE + + +trait Doorman { + fn greet_customer(&self, customer_name: &str); +} + +struct GreeterWithState<'a> { + greeting: &'a str, +} + +impl Doorman for GreeterWithState<'_> { + fn greet_customer(&self, customer_name: &str) { + println!("{}, {}?", self.greeting, customer_name); + } +} + +fn greet_customers(doorman: impl Doorman) { + doorman.greet_customer("Bill"); + doorman.greet_customer("Alex"); + doorman.greet_customer("John"); + doorman.greet_customer("Jessie"); +} + +fn greet_customers_closure(doorman: impl Fn(&str)) { + doorman("Bill"); + doorman("Alex"); + doorman("John"); + doorman("Jessie"); +} + +fn main() { + let greeting = String::from("Hello! How are you"); + + // Method 1 for passing in functions with state. + // Just create a struct, store the state, and add a method. + // If you need to be generic, it can be a trait method. + let doorman = GreeterWithState { + greeting: &greeting, + }; + greet_customers(doorman); + + // Method 2 for passing in functions with state. + // Notice that the body of this closure is exactly the same + // as GreeterWithState's Doorman implementation. + // + // This makes things much cleaner with less clutter, but + // we are forgetting something very important. + greet_customers_closure(|customer_name| { + println!("{}, {}?", self.greeting, customer_name); // TODO: Only modify this line + }) +} diff --git a/exercises/README.md b/exercises/README.md index 237f2f1edc..6446f44279 100644 --- a/exercises/README.md +++ b/exercises/README.md @@ -19,6 +19,7 @@ | traits | §10.2 | | lifetimes | §10.3 | | tests | §11.1 | +| closures | §13.1 | | iterators | §13.2-4 | | smart_pointers | §15, §16.3 | | threads | §16.1-3 | diff --git a/rustlings-macros/info.toml b/rustlings-macros/info.toml index e705598187..c1f4fe98ab 100644 --- a/rustlings-macros/info.toml +++ b/rustlings-macros/info.toml @@ -877,6 +877,17 @@ To handle that, you need to add a special attribute to the test function. You can refer to the docs: https://doc.rust-lang.org/book/ch11-01-writing-tests.html#checking-for-panics-with-should_panic""" +# CLOSURES + +[[exercises]] +name = "closures1" +path = "exercises/18_closures/closures1.rs" +mode = "compile" +hint = """ +Self is a concept that is only used in struct/enum methods. + +Closures in Rust do not have a self to refer to, unlike other languages that might use this or self.""" + # STANDARD LIBRARY TYPES [[exercises]] From d9cfdf7c654eddcf5fff6f295e6505f5597e6794 Mon Sep 17 00:00:00 2001 From: junderw Date: Fri, 1 Nov 2024 16:53:50 +0900 Subject: [PATCH 2/3] Update closures --- exercises/18_closures/closures1.rs | 2 - rustlings-macros/info.toml | 3 +- solutions/18_closures/closures1.rs | 61 ++++++++++++++++++++++++++++++ 3 files changed, 62 insertions(+), 4 deletions(-) create mode 100644 solutions/18_closures/closures1.rs diff --git a/exercises/18_closures/closures1.rs b/exercises/18_closures/closures1.rs index 91396208e7..2e36e9b884 100644 --- a/exercises/18_closures/closures1.rs +++ b/exercises/18_closures/closures1.rs @@ -10,8 +10,6 @@ // // Execute `rustlings hint closures1` or use the `hint` watch subcommand for a hint. -// I AM NOT DONE - trait Doorman { fn greet_customer(&self, customer_name: &str); diff --git a/rustlings-macros/info.toml b/rustlings-macros/info.toml index c1f4fe98ab..72c9b4bbaa 100644 --- a/rustlings-macros/info.toml +++ b/rustlings-macros/info.toml @@ -881,8 +881,7 @@ https://doc.rust-lang.org/book/ch11-01-writing-tests.html#checking-for-panics-wi [[exercises]] name = "closures1" -path = "exercises/18_closures/closures1.rs" -mode = "compile" +dir = "18_closures" hint = """ Self is a concept that is only used in struct/enum methods. diff --git a/solutions/18_closures/closures1.rs b/solutions/18_closures/closures1.rs new file mode 100644 index 0000000000..d85682c436 --- /dev/null +++ b/solutions/18_closures/closures1.rs @@ -0,0 +1,61 @@ +// closures1.rs +// +// "Why do we even need closures?" is a question that gets asked from time to time. +// While it's true that most things that closures can do can also be done with +// regular old structs and enums, closures can make things a lot more clear with a lot +// less clutter compared to structs. +// +// Below is a good example of how one could implement a capturing closure using structs, +// and how closures simplifies this greatly. +// +// Execute `rustlings hint closures1` or use the `hint` watch subcommand for a hint. + +trait Doorman { + fn greet_customer(&self, customer_name: &str); +} + +struct GreeterWithState<'a> { + greeting: &'a str, +} + +impl Doorman for GreeterWithState<'_> { + fn greet_customer(&self, customer_name: &str) { + println!("{}, {}?", self.greeting, customer_name); + } +} + +fn greet_customers(doorman: impl Doorman) { + doorman.greet_customer("Bill"); + doorman.greet_customer("Alex"); + doorman.greet_customer("John"); + doorman.greet_customer("Jessie"); +} + +fn greet_customers_closure(doorman: impl Fn(&str)) { + doorman("Bill"); + doorman("Alex"); + doorman("John"); + doorman("Jessie"); +} + +fn main() { + let greeting = String::from("Hello! How are you"); + + // Method 1 for passing in functions with state. + // Just create a struct, store the state, and add a method. + // If you need to be generic, it can be a trait method. + let doorman = GreeterWithState { + greeting: &greeting, + }; + greet_customers(doorman); + + // Method 2 for passing in functions with state. + // Notice that the body of this closure is exactly the same + // as GreeterWithState's Doorman implementation. + // + // This makes things much cleaner with less clutter, but + // we are forgetting something very important. + greet_customers_closure(|customer_name| { + println!("{}, {}?", greeting, customer_name); // Capture greeting by reference + }) +} From 8aa8b492eabc638ee9aadb281249cc212ec1dd4b Mon Sep 17 00:00:00 2001 From: junderw Date: Fri, 1 Nov 2024 18:45:11 +0900 Subject: [PATCH 3/3] Add closures2.rs --- dev/Cargo.toml | 4 +++ exercises/18_closures/closures2.rs | 47 ++++++++++++++++++++++++++++++ rustlings-macros/info.toml | 12 ++++++++ solutions/18_closures/closures2.rs | 47 ++++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+) create mode 100644 exercises/18_closures/closures2.rs create mode 100644 solutions/18_closures/closures2.rs diff --git a/dev/Cargo.toml b/dev/Cargo.toml index 29a557a019..b4a876ed7e 100644 --- a/dev/Cargo.toml +++ b/dev/Cargo.toml @@ -140,6 +140,10 @@ bin = [ { name = "tests2_sol", path = "../solutions/17_tests/tests2.rs" }, { name = "tests3", path = "../exercises/17_tests/tests3.rs" }, { name = "tests3_sol", path = "../solutions/17_tests/tests3.rs" }, + { name = "closures1", path = "../exercises/18_closures/closures1.rs" }, + { name = "closures1_sol", path = "../solutions/18_closures/closures1.rs" }, + { name = "closures2", path = "../exercises/18_closures/closures2.rs" }, + { name = "closures2_sol", path = "../solutions/18_closures/closures2.rs" }, { name = "iterators1", path = "../exercises/18_iterators/iterators1.rs" }, { name = "iterators1_sol", path = "../solutions/18_iterators/iterators1.rs" }, { name = "iterators2", path = "../exercises/18_iterators/iterators2.rs" }, diff --git a/exercises/18_closures/closures2.rs b/exercises/18_closures/closures2.rs new file mode 100644 index 0000000000..15bc2b621b --- /dev/null +++ b/exercises/18_closures/closures2.rs @@ -0,0 +1,47 @@ +// closures2.rs +// +// How do closures capture their state? Well, the answer is "it depends on how you use it!" +// +// Usage inside the closure body will tell the compiler how the value should be captured. +// +// Capture by shared reference? Mutable reference? Ownership? Let's try and see! +// +// Execute `rustlings hint closures2` or use the `hint` watch subcommand for a hint. + +fn main() { + // Using a non-Copy type because it makes reasoning about capturing easier + let s = String::from("Hello, rustlings!"); + let capture_by_ref = || { + println!("{s}"); // This only requires a &String, so it only captures a &String + }; + // You can continue to use s as a &String outside the closure, but not &mut String or String. + println!("Outside capture_by_ref closure: {s}"); + capture_by_ref(); + + // Notice the mut here + // v + let mut s = String::from("Hello, rustlings!"); + let mut capture_by_mut = || { + s.truncate(5); // Requires &mut String: also can be written as String::truncate(&mut s, 5); + println!("{s}"); // This should print nothing (and a line break) + // Since the "most" we need is mutable, it captures a single mutable reference to String. + }; + capture_by_mut(); + + let mut s = String::from("Hello, rustlings!"); + let capture_by_ownership = || { + s.truncate(5); // Requires &mut String + println!("{s}"); // This should print nothing (and a line break) + let boxed = s.into_boxed_str(); // Requires ownership: String::into_boxed_str(s); + println!("{boxed}"); // This should print nothing (and a line break) + }; + capture_by_ownership(); + + let mut s = String::from("Hello, rustlings!"); + let mut quiz = || { + let captured_s = &mut s; // TODO Fix this compiler error + println!("Inside Closure quiz {captured_s}"); + }; + println!("Outside Closure quiz {s}"); + quiz(); +} diff --git a/rustlings-macros/info.toml b/rustlings-macros/info.toml index 72c9b4bbaa..5ebe575906 100644 --- a/rustlings-macros/info.toml +++ b/rustlings-macros/info.toml @@ -882,11 +882,23 @@ https://doc.rust-lang.org/book/ch11-01-writing-tests.html#checking-for-panics-wi [[exercises]] name = "closures1" dir = "18_closures" +test = false hint = """ Self is a concept that is only used in struct/enum methods. Closures in Rust do not have a self to refer to, unlike other languages that might use this or self.""" +[[exercises]] +name = "closures2" +dir = "18_closures" +test = false +hint = """ +Capturing a mutable reference manually will also force the closure to capture s by mutable reference. + +The println macro only requires a shared reference. + +Also make sure that you don't declare s or the closure with mut when it is no longer necessary.""" + # STANDARD LIBRARY TYPES [[exercises]] diff --git a/solutions/18_closures/closures2.rs b/solutions/18_closures/closures2.rs new file mode 100644 index 0000000000..29858e39f8 --- /dev/null +++ b/solutions/18_closures/closures2.rs @@ -0,0 +1,47 @@ +// closures2.rs +// +// How do closures capture their state? Well, the answer is "it depends on how you use it!" +// +// Usage inside the closure body will tell the compiler how the value should be captured. +// +// Capture by shared reference? Mutable reference? Ownership? Let's try and see! +// +// Execute `rustlings hint closures2` or use the `hint` watch subcommand for a hint. + +fn main() { + // Using a non-Copy type because it makes reasoning about capturing easier + let s = String::from("Hello, rustlings!"); + let capture_by_ref = || { + println!("{s}"); // This only requires a &String, so it only captures a &String + }; + // You can continue to use s as a &String outside the closure, but not &mut String or String. + println!("Outside capture_by_ref closure: {s}"); + capture_by_ref(); + + // Notice the mut here + // v + let mut s = String::from("Hello, rustlings!"); + let mut capture_by_mut = || { + s.truncate(5); // Requires &mut String: also can be written as String::truncate(&mut s, 5); + println!("{s}"); // This should print nothing (and a line break) + // Since the "most" we need is mutable, it captures a single mutable reference to String. + }; + capture_by_mut(); + + let mut s = String::from("Hello, rustlings!"); + let capture_by_ownership = || { + s.truncate(5); // Requires &mut String + println!("{s}"); // This should print nothing (and a line break) + let boxed = s.into_boxed_str(); // Requires ownership: String::into_boxed_str(s); + println!("{boxed}"); // This should print nothing (and a line break) + }; + capture_by_ownership(); + + let s = String::from("Hello, rustlings!"); + let quiz = || { + let captured_s = &s; // Using a shared reference fixes the issue. + println!("Inside Closure quiz {captured_s}"); + }; + println!("Outside Closure quiz {s}"); + quiz(); +}