",
+]
+edition = "2021"
[dependencies]
-clap = "2.32.0"
-indicatif = "0.10.3"
-console = "0.7.7"
-notify = "4.0.15"
-toml = "0.4.10"
-regex = "1.1.6"
-serde = {version = "1.0.10", features = ["derive"]}
+argh = "0.1"
+indicatif = "0.16"
+console = "0.15"
+notify = "4.0"
+toml = "0.5"
+regex = "1.5"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.81"
+home = "0.5.3"
+glob = "0.3.0"
[[bin]]
name = "rustlings"
diff --git a/README.md b/README.md
index 6724f05a..12bd3925 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,14 @@
-
-
-[](#contributors-)
-
+
-# rustlings 🦀❤️ [](https://buildkite.com/mokou/rustlings)
+# rustlings 🦀❤️
+
+
Greetings and welcome to `rustlings`. This project contains small exercises to get you used to reading and writing Rust code. This includes reading and responding to compiler messages!
_...looking for the old, web-based version of Rustlings? Try [here](https://github.com/rust-lang/rustlings/tree/rustlings-1)_
-Alternatively, for a first-time Rust learner, there's several other resources:
+Alternatively, for a first-time Rust learner, there are several other resources:
- [The Book](https://doc.rust-lang.org/book/index.html) - The most comprehensive resource for learning Rust, but a bit theoretical sometimes. You will be using this along with Rustlings!
- [Rust By Example](https://doc.rust-lang.org/rust-by-example/index.html) - Learn Rust by solving little exercises! It's almost like `rustlings`, but online
@@ -17,6 +16,7 @@ Alternatively, for a first-time Rust learner, there's several other resources:
## Getting Started
_Note: If you're on MacOS, make sure you've installed Xcode and its developer tools by typing `xcode-select --install`._
+_Note: If you're on Linux, make sure you've installed gcc. Deb: `sudo apt install gcc`. Yum: `sudo yum -y install gcc`._
You will need to have Rust installed. You can get it by visiting https://rustup.rs. This'll also install Cargo, Rust's package/project manager.
@@ -25,41 +25,67 @@ You will need to have Rust installed. You can get it by visiting https://rustup.
Just run:
```bash
-curl -L https://git.io/rustlings | bash
-# Or if you want it to be installed to a different path:
-curl -L https://git.io/rustlings | bash -s mypath/
+curl -L https://raw.githubusercontent.com/rust-lang/rustlings/main/install.sh | bash
+```
+Or if you want it to be installed to a different path:
+
+```bash
+curl -L https://raw.githubusercontent.com/rust-lang/rustlings/main/install.sh | bash -s mypath/
```
This will install Rustlings and give you access to the `rustlings` command. Run it to get started!
+### Nix
+
+Basically: Clone the repository at the latest tag, finally run `nix develop` or `nix-shell`.
+
+```bash
+# find out the latest version at https://github.com/rust-lang/rustlings/releases/latest (on edit 5.5.1)
+git clone -b 5.5.1 --depth 1 https://github.com/rust-lang/rustlings
+cd rustlings
+# if nix version > 2.3
+nix develop
+# if nix version <= 2.3
+nix-shell
+```
+
## Windows
-In PowerShell, set `ExecutionPolicy` to `RemoteSigned`:
+In PowerShell (Run as Administrator), set `ExecutionPolicy` to `RemoteSigned`:
-```ps
-Set-ExecutionPolicy RemoteSigned
+```ps1
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
```
Then, you can run:
-```ps
-Start-BitsTransfer -Source https://git.io/rustlings-win -Destination $env:TMP/install_rustlings.ps1; Unblock-File $env:TMP/install_rustlings.ps1; Invoke-Expression $env:TMP/install_rustlings.ps1
+```ps1
+Start-BitsTransfer -Source https://raw.githubusercontent.com/rust-lang/rustlings/main/install.ps1 -Destination $env:TMP/install_rustlings.ps1; Unblock-File $env:TMP/install_rustlings.ps1; Invoke-Expression $env:TMP/install_rustlings.ps1
```
-To install Rustlings. Same as on MacOS/Linux, you will have access to the `rustlings` command after it.
+To install Rustlings. Same as on MacOS/Linux, you will have access to the `rustlings` command after it. Keep in mind that this works best in PowerShell, and any other terminals may give you errors.
+
+If you get a permission denied message, you might have to exclude the directory where you cloned Rustlings in your antivirus.
+
+## Browser
+
+[](https://gitpod.io/#https://github.com/rust-lang/rustlings)
+
+[](https://github.com/codespaces/new/?repo=rust-lang%2Frustlings&ref=main)
## Manually
-Basically: Clone the repository, checkout to the latest tag, run `cargo install`.
+Basically: Clone the repository at the latest tag, run `cargo install --path .`.
```bash
-git clone https://github.com/rust-lang/rustlings
+# find out the latest version at https://github.com/rust-lang/rustlings/releases/latest (on edit 5.5.1)
+git clone -b 5.5.1 --depth 1 https://github.com/rust-lang/rustlings
cd rustlings
-git checkout tags/3.0.0 # or whatever the latest version is (find out at https://github.com/rust-lang/rustlings/releases/latest)
cargo install --force --path .
```
If there are installation errors, ensure that your toolchain is up to date. For the latest, run:
+
```bash
rustup update
```
@@ -70,7 +96,7 @@ Then, same as above, run `rustlings` to get started.
The exercises are sorted by topic and can be found in the subdirectory `rustlings/exercises/`. For every topic there is an additional README file with some resources to get you started on the topic. We really recommend that you have a look at them before you start.
-The task is simple. Most exercises contain an error that keep it from compiling, and it's up to you to fix it! Some exercises are also run as tests, but rustlings handles them all the same. To run the exercises in the recommended order, execute:
+The task is simple. Most exercises contain an error that keeps them from compiling, and it's up to you to fix it! Some exercises are also run as tests, but rustlings handles them all the same. To run the exercises in the recommended order, execute:
```bash
rustlings watch
@@ -90,111 +116,68 @@ In case you want to go by your own order, or want to only verify a single exerci
rustlings run myExercise1
```
+Or simply use the following command to run the next unsolved exercise in the course:
+
+```bash
+rustlings run next
+```
+
In case you get stuck, you can run the following command to get a hint for your
exercise:
-``` bash
+```bash
rustlings hint myExercise1
```
+You can also get the hint for the next unsolved exercise with the following command:
+
+```bash
+rustlings hint next
+```
+
+To check your progress, you can run the following command:
+
+```bash
+rustlings list
+```
+
## Testing yourself
After every couple of sections, there will be a quiz that'll test your knowledge on a bunch of sections at once. These quizzes are found in `exercises/quizN.rs`.
-## Completion
+## Enabling `rust-analyzer`
-Rustlings isn't done; there are a couple of sections that are very experimental and don't have proper documentation. These include:
+Run the command `rustlings lsp` which will generate a `rust-project.json` at the root of the project, this allows [rust-analyzer](https://rust-analyzer.github.io/) to parse each exercise.
-- Errors (`exercises/errors/`)
-- Option (`exercises/option/`)
-- Result (`exercises/result/`)
-- Move Semantics (could still be improved, `exercises/move_semantics/`)
+## Continuing On
-Additionally, we could use exercises on a couple of topics:
+Once you've completed Rustlings, put your new knowledge to good use! Continue practicing your Rust skills by building your own projects, contributing to Rustlings, or finding other open-source projects to contribute to.
-- Structs
-- Better ownership stuff
-- `impl`
-- ??? probably more
+## Uninstalling Rustlings
-If you are interested in improving or adding new ones, please feel free to contribute! Read on for more information :)
+If you want to remove Rustlings from your system, there are two steps. First, you'll need to remove the exercises folder that the install script created
+for you:
+
+```bash
+rm -rf rustlings # or your custom folder name, if you chose and or renamed it
+```
+
+Second, run `cargo uninstall` to remove the `rustlings` binary:
+
+```bash
+cargo uninstall rustlings
+```
+
+Now you should be done!
## Contributing
See [CONTRIBUTING.md](./CONTRIBUTING.md).
+Development-focused discussion about Rustlings happens in the [**rustlings** stream](https://rust-lang.zulipchat.com/#narrow/stream/334454-rustlings)
+on the [Rust Project Zulip](https://rust-lang.zulipchat.com). Feel free to start a new thread there
+if you have ideas or suggestions!
+
## Contributors ✨
-Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):
-
-
-
-
-
-
-
-
-
-
-This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!
+Thanks goes to the wonderful people listed in [AUTHORS.md](./AUTHORS.md) 🎉
diff --git a/buildkite.yml b/buildkite.yml
deleted file mode 100644
index 91a0753c..00000000
--- a/buildkite.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-steps:
- - label: "Test with stable"
- command: rustup run stable cargo test
- - label: "Test with beta"
- command: rustup run beta cargo test
diff --git a/default_out.txt b/default_out.txt
deleted file mode 100644
index 05267591..00000000
--- a/default_out.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-Thanks for installing Rustlings!
-
-Is this your first time?
-
-Let's make sure you're up to speed:
-- You have Rust installed, preferably via `rustup`
-- You have `~/.cargo/bin` added to your PATH variable
-- You have cloned this repository (https://github.com/rust-lang/rustlings)
-- You have installed Rust language support for your editor
-- You have locally installed the `rustlings` command by running an
- installation script or manually executing:
-
-cargo install --force --path .
-
-If you've done all of this (or even most of it), congrats! You're ready
-to start working with Rust.
-
-To get started, run `rustlings watch` in order to get the first exercise.
-Make sure to have your editor open!
diff --git a/exercises/README.md b/exercises/README.md
new file mode 100644
index 00000000..c7effa95
--- /dev/null
+++ b/exercises/README.md
@@ -0,0 +1,27 @@
+# Exercise to Book Chapter mapping
+
+| Exercise | Book Chapter |
+| ---------------------- | ------------------- |
+| variables | §3.1 |
+| functions | §3.3 |
+| if | §3.5 |
+| primitive_types | §3.2, §4.3 |
+| vecs | §8.1 |
+| move_semantics | §4.1-2 |
+| structs | §5.1, §5.3 |
+| enums | §6, §18.3 |
+| strings | §8.2 |
+| modules | §7 |
+| hashmaps | §8.3 |
+| options | §10.1 |
+| error_handling | §9 |
+| generics | §10 |
+| traits | §10.2 |
+| tests | §11.1 |
+| lifetimes | §10.3 |
+| iterators | §13.2-4 |
+| threads | §16.1-3 |
+| smart_pointers | §15, §16.3 |
+| macros | §19.6 |
+| clippy | §21.4 |
+| conversions | n/a |
diff --git a/exercises/clippy/README.md b/exercises/clippy/README.md
index 60a12fe5..55438af6 100644
--- a/exercises/clippy/README.md
+++ b/exercises/clippy/README.md
@@ -1,8 +1,10 @@
-### Clippy
+# Clippy
The Clippy tool is a collection of lints to analyze your code so you can catch common mistakes and improve your Rust code.
If you used the installation script for Rustlings, Clippy should be already installed.
If not you can install it manually via `rustup component add clippy`.
-For more information about Clippy lints, please see [their documentation page](https://rust-lang.github.io/rust-clippy/master/).
+## Further information
+
+- [GitHub Repository](https://github.com/rust-lang/rust-clippy).
diff --git a/exercises/clippy/clippy1.rs b/exercises/clippy/clippy1.rs
index eb712b28..d1166816 100644
--- a/exercises/clippy/clippy1.rs
+++ b/exercises/clippy/clippy1.rs
@@ -1,15 +1,35 @@
// clippy1.rs
-// The Clippy tool is a collection of lints to analyze your code
-// so you can catch common mistakes and improve your Rust code.
//
-// For these exercises the code will fail to compile when there are clippy warnings
-// check clippy's suggestions from the output to solve the exercise.
-// Execute `rustlings hint clippy1` for hints :)
+// The Clippy tool is a collection of lints to analyze your code so you can
+// catch common mistakes and improve your Rust code.
+//
+// For these exercises the code will fail to compile when there are clippy
+// warnings check clippy's suggestions from the output to solve the exercise.
+//
+// Execute `rustlings hint clippy1` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
fn main() {
let x = 1.2331f64;
let y = 1.2332f64;
if (x - y).abs() < 0.00001 {
println!("Success!");
}
+=======
+// I AM NOT DONE
+
+use std::f32;
+
+fn main() {
+ let pi = 3.14f32;
+ let radius = 5.00f32;
+
+ let area = pi * f32::powi(radius, 2);
+
+ println!(
+ "The area of a circle with radius {:.2} is {:.5}!",
+ radius, area
+ )
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
diff --git a/exercises/clippy/clippy2.rs b/exercises/clippy/clippy2.rs
index 4cdfbe75..79c5c9fe 100644
--- a/exercises/clippy/clippy2.rs
+++ b/exercises/clippy/clippy2.rs
@@ -1,5 +1,7 @@
// clippy2.rs
-// Make me compile! Execute `rustlings hint clippy2` for hints :)
+//
+// Execute `rustlings hint clippy2` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let mut res = 42;
diff --git a/exercises/clippy/clippy3.rs b/exercises/clippy/clippy3.rs
new file mode 100644
index 00000000..35021f84
--- /dev/null
+++ b/exercises/clippy/clippy3.rs
@@ -0,0 +1,31 @@
+// clippy3.rs
+//
+// Here's a couple more easy Clippy fixes, so you can see its utility.
+//
+// Execute `rustlings hint clippy3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#[allow(unused_variables, unused_assignments)]
+fn main() {
+ let my_option: Option<()> = None;
+ if my_option.is_none() {
+ my_option.unwrap();
+ }
+
+ let my_arr = &[
+ -1, -2, -3
+ -4, -5, -6
+ ];
+ println!("My array! Here it is: {:?}", my_arr);
+
+ let my_empty_vec = vec![1, 2, 3, 4, 5].resize(0, 5);
+ println!("This Vec is empty, see? {:?}", my_empty_vec);
+
+ let mut value_a = 45;
+ let mut value_b = 66;
+ // Let's swap these two!
+ value_a = value_b;
+ value_b = value_a;
+ println!("value a: {}; value b: {}", value_a, value_b);
+}
diff --git a/exercises/conversions/README.md b/exercises/conversions/README.md
index 114bd428..619a78c5 100644
--- a/exercises/conversions/README.md
+++ b/exercises/conversions/README.md
@@ -1,5 +1,4 @@
-### Type conversions
-
+# Type conversions
Rust offers a multitude of ways to convert a value of a given type into another type.
@@ -7,6 +6,7 @@ The simplest form of type conversion is a type cast expression. It is denoted wi
Rust also offers traits that facilitate type conversions upon implementation. These traits can be found under the [`convert`](https://doc.rust-lang.org/std/convert/index.html) module.
The traits are the following:
+
- `From` and `Into` covered in [`from_into`](from_into.rs)
- `TryFrom` and `TryInto` covered in [`try_from_into`](try_from_into.rs)
- `AsRef` and `AsMut` covered in [`as_ref_mut`](as_ref_mut.rs)
@@ -15,6 +15,9 @@ Furthermore, the `std::str` module offers a trait called [`FromStr`](https://doc
These should be the main ways ***within the standard library*** to convert data into your desired types.
-#### Book Sections
+## Further information
-These are not directly covered in the book, but the standard library has great documentation for [conversions here](https://doc.rust-lang.org/std/convert/index.html). The `FromStr` trait is also covered [here](https://doc.rust-lang.org/std/str/trait.FromStr.html).
\ No newline at end of file
+These are not directly covered in the book, but the standard library has a great documentation for it.
+
+- [conversions](https://doc.rust-lang.org/std/convert/index.html)
+- [`FromStr` trait](https://doc.rust-lang.org/std/str/trait.FromStr.html)
diff --git a/exercises/conversions/as_ref_mut.rs b/exercises/conversions/as_ref_mut.rs
index 963c0f2d..626a36c4 100644
--- a/exercises/conversions/as_ref_mut.rs
+++ b/exercises/conversions/as_ref_mut.rs
@@ -1,24 +1,31 @@
-// AsRef and AsMut allow for cheap reference-to-reference conversions.
-// Read more about them at https://doc.rust-lang.org/std/convert/trait.AsRef.html
-// and https://doc.rust-lang.org/std/convert/trait.AsMut.html, respectively.
+// as_ref_mut.rs
+//
+// AsRef and AsMut allow for cheap reference-to-reference conversions. Read more
+// about them at https://doc.rust-lang.org/std/convert/trait.AsRef.html and
+// https://doc.rust-lang.org/std/convert/trait.AsMut.html, respectively.
+//
+// Execute `rustlings hint as_ref_mut` or use the `hint` watch subcommand for a
+// hint.
// I AM NOT DONE
-// Obtain the number of bytes (not characters) in the given argument
-// Add the AsRef trait appropriately as a trait bound
+
+// Obtain the number of bytes (not characters) in the given argument.
+// TODO: Add the AsRef trait appropriately as a trait bound.
fn byte_counter(arg: T) -> usize {
arg.as_ref().as_bytes().len()
}
-// Obtain the number of characters (not bytes) in the given argument
-// Add the AsRef trait appropriately as a trait bound
+// Obtain the number of characters (not bytes) in the given argument.
+// TODO: Add the AsRef trait appropriately as a trait bound.
fn char_counter(arg: T) -> usize {
arg.as_ref().chars().count()
}
-fn main() {
- let s = "Café au lait";
- println!("{}", char_counter(s));
- println!("{}", byte_counter(s));
+// Squares a number using as_mut().
+// TODO: Add the appropriate trait bound.
+fn num_sq(arg: &mut T) {
+ // TODO: Implement the function body.
+ ???
}
#[cfg(test)]
@@ -48,4 +55,11 @@ mod tests {
let s = String::from("Cafe au lait");
assert_eq!(char_counter(s.clone()), byte_counter(s));
}
+
+ #[test]
+ fn mult_box() {
+ let mut num: Box = Box::new(3);
+ num_sq(&mut num);
+ assert_eq!(*num, 9);
+ }
}
diff --git a/exercises/conversions/from_into.rs b/exercises/conversions/from_into.rs
index 0bfe555b..ea4eced7 100644
--- a/exercises/conversions/from_into.rs
+++ b/exercises/conversions/from_into.rs
@@ -1,6 +1,12 @@
-// The From trait is used for value-to-value conversions.
-// If From is implemented correctly for a type, the Into trait should work conversely.
-// You can read more about it at https://doc.rust-lang.org/std/convert/trait.From.html
+// from_into.rs
+//
+// The From trait is used for value-to-value conversions. If From is implemented
+// correctly for a type, the Into trait should work conversely. You can read
+// more about it at https://doc.rust-lang.org/std/convert/trait.From.html
+//
+// Execute `rustlings hint from_into` or use the `hint` watch subcommand for a
+// hint.
+
#[derive(Debug)]
struct Person {
name: String,
@@ -18,20 +24,32 @@ impl Default for Person {
}
}
+<<<<<<< HEAD
// Your task is to complete this implementation
// in order for the line `let p = Person::from("Mark,20")` to compile
// Please note that you'll need to parse the age component into a `usize`
// with something like `"4".parse::()`. The outcome of this needs to
// be handled appropriately.
+=======
+// Your task is to complete this implementation in order for the line `let p =
+// Person::from("Mark,20")` to compile Please note that you'll need to parse the
+// age component into a `usize` with something like `"4".parse::()`. The
+// outcome of this needs to be handled appropriately.
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
//
// Steps:
-// 1. If the length of the provided string is 0, then return the default of Person
-// 2. Split the given string on the commas present in it
-// 3. Extract the first element from the split operation and use it as the name
-// 4. If the name is empty, then return the default of Person
-// 5. Extract the other element from the split operation and parse it into a `usize` as the age
-// If while parsing the age, something goes wrong, then return the default of Person
-// Otherwise, then return an instantiated Person object with the results
+// 1. If the length of the provided string is 0, then return the default of
+// Person.
+// 2. Split the given string on the commas present in it.
+// 3. Extract the first element from the split operation and use it as the name.
+// 4. If the name is empty, then return the default of Person.
+// 5. Extract the other element from the split operation and parse it into a
+// `usize` as the age.
+// If while parsing the age, something goes wrong, then return the default of
+// Person Otherwise, then return an instantiated Person object with the results
+
+// I AM NOT DONE
+
impl From<&str> for Person {
fn from(s: &str) -> Person {
// Can be neglected as in this case the age rule will always fail
@@ -89,7 +107,8 @@ mod tests {
}
#[test]
fn test_bad_age() {
- // Test that "Mark.twenty" will return the default person due to an error in parsing age
+ // Test that "Mark,twenty" will return the default person due to an
+ // error in parsing age
let p = Person::from("Mark,twenty");
println!("{:?}", p);
assert_eq!(p.name, "John");
@@ -130,4 +149,18 @@ mod tests {
assert_eq!(p.name, "John");
assert_eq!(p.age, 30);
}
+
+ #[test]
+ fn test_trailing_comma() {
+ let p: Person = Person::from("Mike,32,");
+ assert_eq!(p.name, "John");
+ assert_eq!(p.age, 30);
+ }
+
+ #[test]
+ fn test_trailing_comma_and_some_string() {
+ let p: Person = Person::from("Mike,32,man");
+ assert_eq!(p.name, "John");
+ assert_eq!(p.age, 30);
+ }
}
diff --git a/exercises/conversions/from_str.rs b/exercises/conversions/from_str.rs
index 014d0549..34472c32 100644
--- a/exercises/conversions/from_str.rs
+++ b/exercises/conversions/from_str.rs
@@ -1,27 +1,56 @@
-// This does practically the same thing that TryFrom<&str> does.
-// Additionally, upon implementing FromStr, you can use the `parse` method
-// on strings to generate an object of the implementor type.
-// You can read more about it at https://doc.rust-lang.org/std/str/trait.FromStr.html
+// from_str.rs
+//
+// This is similar to from_into.rs, but this time we'll implement `FromStr` and
+// return errors instead of falling back to a default value. Additionally, upon
+// implementing FromStr, you can use the `parse` method on strings to generate
+// an object of the implementor type. You can read more about it at
+// https://doc.rust-lang.org/std/str/trait.FromStr.html
+//
+// Execute `rustlings hint from_str` or use the `hint` watch subcommand for a
+// hint.
+
+use std::num::ParseIntError;
use std::str::FromStr;
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
struct Person {
name: String,
age: usize,
}
+// We will use this error type for the `FromStr` implementation.
+#[derive(Debug, PartialEq)]
+enum ParsePersonError {
+ // Empty input string
+ Empty,
+ // Incorrect number of fields
+ BadLen,
+ // Empty name field
+ NoName,
+ // Wrapped error from parse::()
+ ParseInt(ParseIntError),
+}
+
// I AM NOT DONE
+
// Steps:
-// 1. If the length of the provided string is 0, then return an error
+// 1. If the length of the provided string is 0, an error should be returned
// 2. Split the given string on the commas present in it
-// 3. Extract the first element from the split operation and use it as the name
-// 4. If the name is empty, then return an error
-// 5. Extract the other element from the split operation and parse it into a `usize` as the age
-// with something like `"4".parse::()`.
-// If while parsing the age, something goes wrong, then return an error
-// Otherwise, then return a Result of a Person object
+// 3. Only 2 elements should be returned from the split, otherwise return an
+// error
+// 4. Extract the first element from the split operation and use it as the name
+// 5. Extract the other element from the split operation and parse it into a
+// `usize` as the age with something like `"4".parse::()`
+// 6. If while extracting the name and the age something goes wrong, an error
+// should be returned
+// If everything goes well, then return a Result of a Person object
+//
+// As an aside: `Box` implements `From<&'_ str>`. This means that if
+// you want to return a string error message, you can do so via just using
+// return `Err("my error message".into())`.
+
impl FromStr for Person {
- type Err = String;
+ type Err = ParsePersonError;
fn from_str(s: &str) -> Result {
}
}
@@ -37,7 +66,7 @@ mod tests {
#[test]
fn empty_input() {
- assert!("".parse::().is_err());
+ assert_eq!("".parse::(), Err(ParsePersonError::Empty));
}
#[test]
fn good_input() {
@@ -48,39 +77,57 @@ mod tests {
assert_eq!(p.age, 32);
}
#[test]
- #[should_panic]
fn missing_age() {
- "John,".parse::().unwrap();
+ assert!(matches!(
+ "John,".parse::(),
+ Err(ParsePersonError::ParseInt(_))
+ ));
}
#[test]
- #[should_panic]
fn invalid_age() {
- "John,twenty".parse::().unwrap();
+ assert!(matches!(
+ "John,twenty".parse::(),
+ Err(ParsePersonError::ParseInt(_))
+ ));
}
#[test]
- #[should_panic]
fn missing_comma_and_age() {
- "John".parse::().unwrap();
+ assert_eq!("John".parse::(), Err(ParsePersonError::BadLen));
}
#[test]
- #[should_panic]
fn missing_name() {
- ",1".parse::().unwrap();
+ assert_eq!(",1".parse::(), Err(ParsePersonError::NoName));
}
#[test]
- #[should_panic]
fn missing_name_and_age() {
- ",".parse::().unwrap();
+ assert!(matches!(
+ ",".parse::(),
+ Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
+ ));
}
#[test]
- #[should_panic]
fn missing_name_and_invalid_age() {
- ",one".parse::().unwrap();
+ assert!(matches!(
+ ",one".parse::(),
+ Err(ParsePersonError::NoName | ParsePersonError::ParseInt(_))
+ ));
}
+ #[test]
+ fn trailing_comma() {
+ assert_eq!("John,32,".parse::(), Err(ParsePersonError::BadLen));
+ }
+
+ #[test]
+ fn trailing_comma_and_some_string() {
+ assert_eq!(
+ "John,32,man".parse::(),
+ Err(ParsePersonError::BadLen)
+ );
+ }
}
diff --git a/exercises/conversions/try_from_into.rs b/exercises/conversions/try_from_into.rs
index dbdbe00e..32d6ef39 100644
--- a/exercises/conversions/try_from_into.rs
+++ b/exercises/conversions/try_from_into.rs
@@ -1,62 +1,77 @@
-// TryFrom is a simple and safe type conversion that may fail in a controlled way under some circumstances.
-// Basically, this is the same as From. The main difference is that this should return a Result type
-// instead of the target type itself.
-// You can read more about it at https://doc.rust-lang.org/std/convert/trait.TryFrom.html
-use std::convert::{TryInto, TryFrom};
+// try_from_into.rs
+//
+// TryFrom is a simple and safe type conversion that may fail in a controlled
+// way under some circumstances. Basically, this is the same as From. The main
+// difference is that this should return a Result type instead of the target
+// type itself. You can read more about it at
+// https://doc.rust-lang.org/std/convert/trait.TryFrom.html
+//
+// Execute `rustlings hint try_from_into` or use the `hint` watch subcommand for
+// a hint.
-#[derive(Debug)]
+use std::convert::{TryFrom, TryInto};
+
+#[derive(Debug, PartialEq)]
struct Color {
red: u8,
green: u8,
blue: u8,
}
+// We will use this error type for these `TryFrom` conversions.
+#[derive(Debug, PartialEq)]
+enum IntoColorError {
+ // Incorrect length of slice
+ BadLen,
+ // Integer conversion error
+ IntConversion,
+}
+
// I AM NOT DONE
-// Your task is to complete this implementation
-// and return an Ok result of inner type Color.
-// You need create implementation for a tuple of three integer,
-// an array of three integer and slice of integer.
+// Your task is to complete this implementation and return an Ok result of inner
+// type Color. You need to create an implementation for a tuple of three
+// integers, an array of three integers, and a slice of integers.
//
-// Note, that implementation for tuple and array will be checked at compile-time,
-// but slice implementation need check slice length!
-// Also note, that chunk of correct rgb color must be integer in range 0..=255.
+// Note that the implementation for tuple and array will be checked at compile
+// time, but the slice implementation needs to check the slice length! Also note
+// that correct RGB color values must be integers in the 0..=255 range.
// Tuple implementation
impl TryFrom<(i16, i16, i16)> for Color {
- type Error = String;
+ type Error = IntoColorError;
fn try_from(tuple: (i16, i16, i16)) -> Result {
}
}
// Array implementation
impl TryFrom<[i16; 3]> for Color {
- type Error = String;
+ type Error = IntoColorError;
fn try_from(arr: [i16; 3]) -> Result {
}
}
// Slice implementation
impl TryFrom<&[i16]> for Color {
- type Error = String;
+ type Error = IntoColorError;
fn try_from(slice: &[i16]) -> Result {
}
}
fn main() {
- // Use the `from` function
+ // Use the `try_from` function
let c1 = Color::try_from((183, 65, 14));
println!("{:?}", c1);
- // Since From is implemented for Color, we should be able to use Into
+ // Since TryFrom is implemented for Color, we should be able to use TryInto
let c2: Result = [183, 65, 14].try_into();
println!("{:?}", c2);
let v = vec![183, 65, 14];
- // With slice we should use `from` function
+ // With slice we should use `try_from` function
let c3 = Color::try_from(&v[..]);
println!("{:?}", c3);
- // or take slice within round brackets and use Into
+ // or take slice within round brackets and use TryInto
let c4: Result = (&v[..]).try_into();
println!("{:?}", c4);
}
@@ -66,65 +81,113 @@ mod tests {
use super::*;
#[test]
- #[should_panic]
fn test_tuple_out_of_range_positive() {
- let _ = Color::try_from((256, 1000, 10000)).unwrap();
+ assert_eq!(
+ Color::try_from((256, 1000, 10000)),
+ Err(IntoColorError::IntConversion)
+ );
}
#[test]
- #[should_panic]
fn test_tuple_out_of_range_negative() {
- let _ = Color::try_from((-1, -10, -256)).unwrap();
+ assert_eq!(
+ Color::try_from((-1, -10, -256)),
+ Err(IntoColorError::IntConversion)
+ );
+ }
+ #[test]
+ fn test_tuple_sum() {
+ assert_eq!(
+ Color::try_from((-1, 255, 255)),
+ Err(IntoColorError::IntConversion)
+ );
}
#[test]
fn test_tuple_correct() {
- let c: Color = (183, 65, 14).try_into().unwrap();
- assert_eq!(c.red, 183);
- assert_eq!(c.green, 65);
- assert_eq!(c.blue, 14);
+ let c: Result = (183, 65, 14).try_into();
+ assert!(c.is_ok());
+ assert_eq!(
+ c.unwrap(),
+ Color {
+ red: 183,
+ green: 65,
+ blue: 14
+ }
+ );
}
-
#[test]
- #[should_panic]
fn test_array_out_of_range_positive() {
- let _: Color = [1000, 10000, 256].try_into().unwrap();
+ let c: Result = [1000, 10000, 256].try_into();
+ assert_eq!(c, Err(IntoColorError::IntConversion));
}
#[test]
- #[should_panic]
fn test_array_out_of_range_negative() {
- let _: Color = [-10, -256, -1].try_into().unwrap();
+ let c: Result = [-10, -256, -1].try_into();
+ assert_eq!(c, Err(IntoColorError::IntConversion));
+ }
+ #[test]
+ fn test_array_sum() {
+ let c: Result = [-1, 255, 255].try_into();
+ assert_eq!(c, Err(IntoColorError::IntConversion));
}
#[test]
fn test_array_correct() {
- let c: Color = [183, 65, 14].try_into().unwrap();
- assert_eq!(c.red, 183);
- assert_eq!(c.green, 65);
- assert_eq!(c.blue, 14);
+ let c: Result = [183, 65, 14].try_into();
+ assert!(c.is_ok());
+ assert_eq!(
+ c.unwrap(),
+ Color {
+ red: 183,
+ green: 65,
+ blue: 14
+ }
+ );
}
-
#[test]
- #[should_panic]
fn test_slice_out_of_range_positive() {
let arr = [10000, 256, 1000];
- let _ = Color::try_from(&arr[..]).unwrap();
+ assert_eq!(
+ Color::try_from(&arr[..]),
+ Err(IntoColorError::IntConversion)
+ );
}
#[test]
- #[should_panic]
fn test_slice_out_of_range_negative() {
let arr = [-256, -1, -10];
- let _ = Color::try_from(&arr[..]).unwrap();
+ assert_eq!(
+ Color::try_from(&arr[..]),
+ Err(IntoColorError::IntConversion)
+ );
+ }
+ #[test]
+ fn test_slice_sum() {
+ let arr = [-1, 255, 255];
+ assert_eq!(
+ Color::try_from(&arr[..]),
+ Err(IntoColorError::IntConversion)
+ );
}
#[test]
fn test_slice_correct() {
let v = vec![183, 65, 14];
- let c = Color::try_from(&v[..]).unwrap();
- assert_eq!(c.red, 183);
- assert_eq!(c.green, 65);
- assert_eq!(c.blue, 14);
+ let c: Result = Color::try_from(&v[..]);
+ assert!(c.is_ok());
+ assert_eq!(
+ c.unwrap(),
+ Color {
+ red: 183,
+ green: 65,
+ blue: 14
+ }
+ );
}
#[test]
- #[should_panic]
fn test_slice_excess_length() {
let v = vec![0, 0, 0, 0];
- let _ = Color::try_from(&v[..]).unwrap();
+ assert_eq!(Color::try_from(&v[..]), Err(IntoColorError::BadLen));
+ }
+ #[test]
+ fn test_slice_insufficient_length() {
+ let v = vec![0, 0];
+ assert_eq!(Color::try_from(&v[..]), Err(IntoColorError::BadLen));
}
}
diff --git a/exercises/conversions/using_as.rs b/exercises/conversions/using_as.rs
index 3781c826..c5cdce08 100644
--- a/exercises/conversions/using_as.rs
+++ b/exercises/conversions/using_as.rs
@@ -1,16 +1,42 @@
-// Type casting in Rust is done via the usage of the `as` operator.
-// Please note that the `as` operator is not only used when type casting.
-// It also helps with renaming imports.
+// using_as.rs
+//
+// Type casting in Rust is done via the usage of the `as` operator. Please note
+// that the `as` operator is not only used when type casting. It also helps with
+// renaming imports.
+//
+// The goal is to make sure that the division does not fail to compile and
+// returns the proper type.
+//
+// Execute `rustlings hint using_as` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
// The goal is to make sure that the division does not fail to compile
fn average(values: &[f64]) -> f64 {
let total = values
.iter()
.fold(0.0, |a, b| a + b);
total / (values.len() as f64)
+=======
+// I AM NOT DONE
+
+fn average(values: &[f64]) -> f64 {
+ let total = values.iter().sum::();
+ total / values.len()
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
fn main() {
let values = [3.5, 0.3, 13.0, 11.7];
println!("{}", average(&values));
-}
\ No newline at end of file
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn returns_proper_type_and_value() {
+ assert_eq!(average(&[3.5, 0.3, 13.0, 11.7]), 7.125);
+ }
+}
diff --git a/exercises/enums/README.md b/exercises/enums/README.md
index a090a43e..30d4d91d 100644
--- a/exercises/enums/README.md
+++ b/exercises/enums/README.md
@@ -1,10 +1,10 @@
-### Enums
+# Enums
-Rust allows you to define types called "enums" which enumerate possible values.
+Rust allows you to define types called "enums" which enumerate possible values.
Enums are a feature in many languages, but their capabilities differ in each language. Rust’s enums are most similar to algebraic data types in functional languages, such as F#, OCaml, and Haskell.
-Useful in combination with enums is Rust's "pattern matching" facility, which makes it easy to run different code for different values of an enumeration.
+Useful in combination with enums is Rust's "pattern matching" facility, which makes it easy to run different code for different values of an enumeration.
-#### Book Sections
+## Further information
- [Enums](https://doc.rust-lang.org/book/ch06-00-enums.html)
- [Pattern syntax](https://doc.rust-lang.org/book/ch18-03-pattern-syntax.html)
diff --git a/exercises/enums/enums1.rs b/exercises/enums/enums1.rs
index 2baa8f2b..57f15bea 100644
--- a/exercises/enums/enums1.rs
+++ b/exercises/enums/enums1.rs
@@ -1,5 +1,6 @@
// enums1.rs
-// Make me compile! Execute `rustlings hint enums1` for hints!
+//
+// No hints this time! ;)
#[derive(Debug)]
enum Message {
diff --git a/exercises/enums/enums2.rs b/exercises/enums/enums2.rs
index bfed553c..d6c3ed39 100644
--- a/exercises/enums/enums2.rs
+++ b/exercises/enums/enums2.rs
@@ -1,5 +1,7 @@
// enums2.rs
-// Make me compile! Execute `rustlings hint enums2` for hints!
+//
+// Execute `rustlings hint enums2` or use the `hint` watch subcommand for a
+// hint.
#[derive(Debug)]
enum Message {
@@ -12,16 +14,16 @@ enum Message {
impl Message {
fn call(&self) {
- println!("{:?}", &self);
+ println!("{:?}", self);
}
}
fn main() {
let messages = [
- Message::Move{ x: 10, y: 30 },
+ Message::Move { x: 10, y: 30 },
Message::Echo(String::from("hello world")),
Message::ChangeColor(200, 255, 255),
- Message::Quit
+ Message::Quit,
];
for message in &messages {
diff --git a/exercises/enums/enums3.rs b/exercises/enums/enums3.rs
index 6f3ab78b..cd39e670 100644
--- a/exercises/enums/enums3.rs
+++ b/exercises/enums/enums3.rs
@@ -1,5 +1,9 @@
// enums3.rs
+//
// Address all the TODOs to make the tests pass!
+//
+// Execute `rustlings hint enums3` or use the `hint` watch subcommand for a
+// hint.
enum Message {
// TODO: implement the message variant types based on their usage below
@@ -11,13 +15,14 @@ enum Message {
struct Point {
x: u8,
- y: u8
+ y: u8,
}
struct State {
color: (u8, u8, u8),
position: Point,
- quit: bool
+ quit: bool,
+ message: String
}
impl State {
@@ -29,15 +34,14 @@ impl State {
self.quit = true;
}
- fn echo(&self, s: String) {
- println!("{}", s);
- }
+ fn echo(&mut self, s: String) { self.message = s }
fn move_position(&mut self, p: Point) {
self.position = p;
}
fn process(&mut self, message: Message) {
+<<<<<<< HEAD
// TODO: create a match expression to process the different message variants
match message {
Message::ChangeColor(r, g, b) => self.change_color((r, g, b)),
@@ -48,6 +52,12 @@ impl State {
},
_ => self.quit(),
}
+=======
+ // TODO: create a match expression to process the different message
+ // variants
+ // Remember: When passing a tuple as a function argument, you'll need
+ // extra parentheses: fn function((t, u, p, l, e))
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
}
@@ -57,20 +67,25 @@ mod tests {
#[test]
fn test_match_message_call() {
- let mut state = State{
+ let mut state = State {
quit: false,
- position: Point{ x: 0, y: 0 },
- color: (0, 0, 0)
+ position: Point { x: 0, y: 0 },
+ color: (0, 0, 0),
+ message: "hello world".to_string(),
};
state.process(Message::ChangeColor(255, 0, 255));
state.process(Message::Echo(String::from("hello world")));
+<<<<<<< HEAD
state.process(Message::Move{ x: 10, y: 15 });
+=======
+ state.process(Message::Move(Point { x: 10, y: 15 }));
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
state.process(Message::Quit);
assert_eq!(state.color, (255, 0, 255));
assert_eq!(state.position.x, 10);
assert_eq!(state.position.y, 15);
assert_eq!(state.quit, true);
+ assert_eq!(state.message, "hello world");
}
-
}
diff --git a/exercises/error_handling/README.md b/exercises/error_handling/README.md
index cf66c2be..3b21f2b7 100644
--- a/exercises/error_handling/README.md
+++ b/exercises/error_handling/README.md
@@ -1,5 +1,12 @@
-For this exercise check out the sections:
-- [Error Handling](https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html)
-- [Generics](https://doc.rust-lang.org/book/ch10-01-syntax.html)
+# Error handling
-of the Rust Book.
+Most errors aren’t serious enough to require the program to stop entirely.
+Sometimes, when a function fails, it’s for a reason that you can easily interpret and respond to.
+For example, if you try to open a file and that operation fails because the file doesn’t exist, you might want to create the file instead of terminating the process.
+
+## Further information
+
+- [Error Handling](https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html)
+- [Generics](https://doc.rust-lang.org/book/ch10-01-syntax.html)
+- [Result](https://doc.rust-lang.org/rust-by-example/error/result.html)
+- [Boxing errors](https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/boxing_errors.html)
diff --git a/exercises/error_handling/errors1.rs b/exercises/error_handling/errors1.rs
index 7a068395..0e027dce 100644
--- a/exercises/error_handling/errors1.rs
+++ b/exercises/error_handling/errors1.rs
@@ -1,17 +1,31 @@
// errors1.rs
-// This function refuses to generate text to be printed on a nametag if
-// you pass it an empty string. It'd be nicer if it explained what the problem
-// was, instead of just sometimes returning `None`. The 2nd test currently
-// does not compile or pass, but it illustrates the behavior we would like
-// this function to have.
-// Execute `rustlings hint errors1` for hints!
+//
+// This function refuses to generate text to be printed on a nametag if you pass
+// it an empty string. It'd be nicer if it explained what the problem was,
+// instead of just sometimes returning `None`. Thankfully, Rust has a similar
+// construct to `Result` that can be used to express error conditions. Let's use
+// it!
+//
+// Execute `rustlings hint errors1` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
pub fn generate_nametag_text(name: String) -> Result {
if name.len() > 0 {
Ok(format!("Hi! My name is {}", name))
} else {
// Empty names aren't allowed.
Err("`name` was empty; it must be nonempty.".into())
+=======
+// I AM NOT DONE
+
+pub fn generate_nametag_text(name: String) -> Option {
+ if name.is_empty() {
+ // Empty names aren't allowed.
+ None
+ } else {
+ Some(format!("Hi! My name is {}", name))
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
}
@@ -19,9 +33,6 @@ pub fn generate_nametag_text(name: String) -> Result {
mod tests {
use super::*;
- // This test passes initially if you comment out the 2nd test.
- // You'll need to update what this test expects when you change
- // the function under test!
#[test]
fn generates_nametag_text_for_a_nonempty_name() {
assert_eq!(
@@ -34,6 +45,7 @@ mod tests {
fn explains_why_generating_nametag_text_fails() {
assert_eq!(
generate_nametag_text("".into()),
+ // Don't change this line
Err("`name` was empty; it must be nonempty.".into())
);
}
diff --git a/exercises/error_handling/errors2.rs b/exercises/error_handling/errors2.rs
index 08e72e38..72af5bd7 100644
--- a/exercises/error_handling/errors2.rs
+++ b/exercises/error_handling/errors2.rs
@@ -1,20 +1,23 @@
// errors2.rs
+//
// Say we're writing a game where you can buy items with tokens. All items cost
// 5 tokens, and whenever you purchase items there is a processing fee of 1
-// token. A player of the game will type in how many items they want to buy,
-// and the `total_cost` function will calculate the total number of tokens.
-// Since the player typed in the quantity, though, we get it as a string-- and
-// they might have typed anything, not just numbers!
-
+// token. A player of the game will type in how many items they want to buy, and
+// the `total_cost` function will calculate the total cost of the tokens. Since
+// the player typed in the quantity, though, we get it as a string-- and they
+// might have typed anything, not just numbers!
+//
// Right now, this function isn't handling the error case at all (and isn't
-// handling the success case properly either). What we want to do is:
-// if we call the `parse` function on a string that is not a number, that
-// function will return a `ParseIntError`, and in that case, we want to
-// immediately return that error from our function and not try to multiply
-// and add.
-
-// There are at least two ways to implement this that are both correct-- but
-// one is a lot shorter! Execute `rustlings hint errors2` for hints to both ways.
+// handling the success case properly either). What we want to do is: if we call
+// the `parse` function on a string that is not a number, that function will
+// return a `ParseIntError`, and in that case, we want to immediately return
+// that error from our function and not try to multiply and add.
+//
+// There are at least two ways to implement this that are both correct-- but one
+// is a lot shorter!
+//
+// Execute `rustlings hint errors2` or use the `hint` watch subcommand for a
+// hint.
use std::num::ParseIntError;
diff --git a/exercises/error_handling/errors3.rs b/exercises/error_handling/errors3.rs
index b799ad8b..ff9705e4 100644
--- a/exercises/error_handling/errors3.rs
+++ b/exercises/error_handling/errors3.rs
@@ -1,8 +1,11 @@
// errors3.rs
+//
// This is a program that is trying to use a completed version of the
// `total_cost` function from the previous exercise. It's not working though!
// Why not? What should we do to fix it?
-// Execute `rustlings hint errors3` for hints!
+//
+// Execute `rustlings hint errors3` or use the `hint` watch subcommand for a
+// hint.
use std::num::ParseIntError;
diff --git a/exercises/error_handling/result1.rs b/exercises/error_handling/errors4.rs
similarity index 67%
rename from exercises/error_handling/result1.rs
rename to exercises/error_handling/errors4.rs
index f555baef..cb69a693 100644
--- a/exercises/error_handling/result1.rs
+++ b/exercises/error_handling/errors4.rs
@@ -1,5 +1,7 @@
-// result1.rs
-// Make this test pass! Execute `rustlings hint result1` for hints :)
+// errors4.rs
+//
+// Execute `rustlings hint errors4` or use the `hint` watch subcommand for a
+// hint.
#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);
@@ -12,6 +14,7 @@ enum CreationError {
impl PositiveNonzeroInteger {
fn new(value: i64) -> Result {
+<<<<<<< HEAD:exercises/error_handling/result1.rs
if value > 1 {
Ok(PositiveNonzeroInteger(value as u64))
} else if value == 0 {
@@ -20,6 +23,10 @@ impl PositiveNonzeroInteger {
Err(CreationError::Negative)
}
+=======
+ // Hmm... Why is this always returning an Ok value?
+ Ok(PositiveNonzeroInteger(value as u64))
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e:exercises/error_handling/errors4.rs
}
}
diff --git a/exercises/error_handling/errors5.rs b/exercises/error_handling/errors5.rs
new file mode 100644
index 00000000..92461a7e
--- /dev/null
+++ b/exercises/error_handling/errors5.rs
@@ -0,0 +1,71 @@
+// errors5.rs
+//
+// This program uses an altered version of the code from errors4.
+//
+// This exercise uses some concepts that we won't get to until later in the
+// course, like `Box` and the `From` trait. It's not important to understand
+// them in detail right now, but you can read ahead if you like. For now, think
+// of the `Box` type as an "I want anything that does ???" type, which,
+// given Rust's usual standards for runtime safety, should strike you as
+// somewhat lenient!
+//
+// In short, this particular use case for boxes is for when you want to own a
+// value and you care only that it is a type which implements a particular
+// trait. To do so, The Box is declared as of type Box where Trait is
+// the trait the compiler looks for on any value used in that context. For this
+// exercise, that context is the potential errors which can be returned in a
+// Result.
+//
+// What can we use to describe both errors? In other words, is there a trait
+// which both errors implement?
+//
+// Execute `rustlings hint errors5` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::error;
+use std::fmt;
+use std::num::ParseIntError;
+
+// TODO: update the return type of `main()` to make this compile.
+fn main() -> Result<(), Box> {
+ let pretend_user_input = "42";
+ let x: i64 = pretend_user_input.parse()?;
+ println!("output={:?}", PositiveNonzeroInteger::new(x)?);
+ Ok(())
+}
+
+// Don't change anything below this line.
+
+#[derive(PartialEq, Debug)]
+struct PositiveNonzeroInteger(u64);
+
+#[derive(PartialEq, Debug)]
+enum CreationError {
+ Negative,
+ Zero,
+}
+
+impl PositiveNonzeroInteger {
+ fn new(value: i64) -> Result {
+ match value {
+ x if x < 0 => Err(CreationError::Negative),
+ x if x == 0 => Err(CreationError::Zero),
+ x => Ok(PositiveNonzeroInteger(x as u64)),
+ }
+ }
+}
+
+// This is required so that `CreationError` can implement `error::Error`.
+impl fmt::Display for CreationError {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let description = match *self {
+ CreationError::Negative => "number is negative",
+ CreationError::Zero => "number is zero",
+ };
+ f.write_str(description)
+ }
+}
+
+impl error::Error for CreationError {}
diff --git a/exercises/error_handling/errors6.rs b/exercises/error_handling/errors6.rs
new file mode 100644
index 00000000..aaf0948e
--- /dev/null
+++ b/exercises/error_handling/errors6.rs
@@ -0,0 +1,94 @@
+// errors6.rs
+//
+// Using catch-all error types like `Box` isn't recommended
+// for library code, where callers might want to make decisions based on the
+// error content, instead of printing it out or propagating it further. Here, we
+// define a custom error type to make it possible for callers to decide what to
+// do next when our function returns an error.
+//
+// Execute `rustlings hint errors6` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::num::ParseIntError;
+
+// This is a custom error type that we will be using in `parse_pos_nonzero()`.
+#[derive(PartialEq, Debug)]
+enum ParsePosNonzeroError {
+ Creation(CreationError),
+ ParseInt(ParseIntError),
+}
+
+impl ParsePosNonzeroError {
+ fn from_creation(err: CreationError) -> ParsePosNonzeroError {
+ ParsePosNonzeroError::Creation(err)
+ }
+ // TODO: add another error conversion function here.
+ // fn from_parseint...
+}
+
+fn parse_pos_nonzero(s: &str) -> Result {
+ // TODO: change this to return an appropriate error instead of panicking
+ // when `parse()` returns an error.
+ let x: i64 = s.parse().unwrap();
+ PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation)
+}
+
+// Don't change anything below this line.
+
+#[derive(PartialEq, Debug)]
+struct PositiveNonzeroInteger(u64);
+
+#[derive(PartialEq, Debug)]
+enum CreationError {
+ Negative,
+ Zero,
+}
+
+impl PositiveNonzeroInteger {
+ fn new(value: i64) -> Result {
+ match value {
+ x if x < 0 => Err(CreationError::Negative),
+ x if x == 0 => Err(CreationError::Zero),
+ x => Ok(PositiveNonzeroInteger(x as u64)),
+ }
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_parse_error() {
+ // We can't construct a ParseIntError, so we have to pattern match.
+ assert!(matches!(
+ parse_pos_nonzero("not a number"),
+ Err(ParsePosNonzeroError::ParseInt(_))
+ ));
+ }
+
+ #[test]
+ fn test_negative() {
+ assert_eq!(
+ parse_pos_nonzero("-555"),
+ Err(ParsePosNonzeroError::Creation(CreationError::Negative))
+ );
+ }
+
+ #[test]
+ fn test_zero() {
+ assert_eq!(
+ parse_pos_nonzero("0"),
+ Err(ParsePosNonzeroError::Creation(CreationError::Zero))
+ );
+ }
+
+ #[test]
+ fn test_positive() {
+ let x = PositiveNonzeroInteger::new(42);
+ assert!(x.is_ok());
+ assert_eq!(parse_pos_nonzero("42"), Ok(x.unwrap()));
+ }
+}
diff --git a/exercises/functions/README.md b/exercises/functions/README.md
index 351ae023..6662d0da 100644
--- a/exercises/functions/README.md
+++ b/exercises/functions/README.md
@@ -1,7 +1,8 @@
-### Functions
+# Functions
-Here, you'll learn how to write functions and how Rust's compiler can trace things way back.
+Here, you'll learn how to write functions and how the Rust compiler can help you debug errors even
+in more complex code.
-#### Book Sections
+## Further information
- [How Functions Work](https://doc.rust-lang.org/book/ch03-03-how-functions-work.html)
diff --git a/exercises/functions/functions1.rs b/exercises/functions/functions1.rs
index 9eb2337f..e2cf2517 100644
--- a/exercises/functions/functions1.rs
+++ b/exercises/functions/functions1.rs
@@ -1,5 +1,7 @@
// functions1.rs
-// Make me compile! Execute `rustlings hint functions1` for hints :)
+//
+// Execute `rustlings hint functions1` or use the `hint` watch subcommand for a
+// hint.
fn main() {
call_me();
diff --git a/exercises/functions/functions2.rs b/exercises/functions/functions2.rs
index 92dac557..6d0a20e9 100644
--- a/exercises/functions/functions2.rs
+++ b/exercises/functions/functions2.rs
@@ -1,11 +1,23 @@
// functions2.rs
+<<<<<<< HEAD
// Make me compile! Execute `rustlings hint functions2` for hints :)s
+=======
+//
+// Execute `rustlings hint functions2` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
fn main() {
call_me(3);
}
+<<<<<<< HEAD
fn call_me(num: i32) {
+=======
+fn call_me(num:) {
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
for i in 0..num {
println!("Ring! Call number {}", i + 1);
}
diff --git a/exercises/functions/functions3.rs b/exercises/functions/functions3.rs
index 4ae2f9af..4d6697ab 100644
--- a/exercises/functions/functions3.rs
+++ b/exercises/functions/functions3.rs
@@ -1,11 +1,13 @@
// functions3.rs
-// Make me compile! Execute `rustlings hint functions3` for hints :)
+//
+// Execute `rustlings hint functions3` or use the `hint` watch subcommand for a
+// hint.
fn main() {
call_me(3);
}
-fn call_me(num: i32) {
+fn call_me(num: u32) {
for i in 0..num {
println!("Ring! Call number {}", i + 1);
}
diff --git a/exercises/functions/functions4.rs b/exercises/functions/functions4.rs
index b6af7c4b..aec6cf35 100644
--- a/exercises/functions/functions4.rs
+++ b/exercises/functions/functions4.rs
@@ -1,8 +1,12 @@
// functions4.rs
-// Make me compile! Execute `rustlings hint functions4` for hints :)
-
-// This store is having a sale where if the price is an even number, you get
-// 10 Rustbucks off, but if it's an odd number, it's 3 Rustbucks off.
+//
+// This store is having a sale where if the price is an even number, you get 10
+// Rustbucks off, but if it's an odd number, it's 3 Rustbucks off. (Don't worry
+// about the function bodies themselves, we're only interested in the signatures
+// for now. If anything, this is a good way to peek ahead to future exercises!)
+//
+// Execute `rustlings hint functions4` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let original_price = 51;
diff --git a/exercises/functions/functions5.rs b/exercises/functions/functions5.rs
index c4469c7f..77f83f09 100644
--- a/exercises/functions/functions5.rs
+++ b/exercises/functions/functions5.rs
@@ -1,9 +1,11 @@
// functions5.rs
-// Make me compile! Execute `rustlings hint functions5` for hints :)
+//
+// Execute `rustlings hint functions5` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let answer = square(3);
- println!("The answer is {}", answer);
+ println!("The square of 3 is {}", answer);
}
fn square(num: i32) -> i32 {
diff --git a/exercises/generics/README.md b/exercises/generics/README.md
index 7105f06f..de46d503 100644
--- a/exercises/generics/README.md
+++ b/exercises/generics/README.md
@@ -1,7 +1,11 @@
-### Generics
+# Generics
-In this section you'll learn about saving yourself many lines of code with generics!
+Generics is the topic of generalizing types and functionalities to broader cases.
+This is extremely useful for reducing code duplication in many ways, but can call for rather involving syntax.
+Namely, being generic requires taking great care to specify over which types a generic type is actually considered valid.
+The simplest and most common use of generics is for type parameters.
-### Book Sections
+## Further information
-- [Generic Data Types](https://doc.rust-lang.org/stable/book/ch10-01-syntax.html)
\ No newline at end of file
+- [Generic Data Types](https://doc.rust-lang.org/stable/book/ch10-01-syntax.html)
+- [Bounds](https://doc.rust-lang.org/rust-by-example/generics/bounds.html)
diff --git a/exercises/generics/generics1.rs b/exercises/generics/generics1.rs
index 62e2f005..1f4fa4ac 100644
--- a/exercises/generics/generics1.rs
+++ b/exercises/generics/generics1.rs
@@ -1,8 +1,12 @@
-// This shopping list program isn't compiling!
-// Use your knowledge of generics to fix it.
+// generics1.rs
+//
+// This shopping list program isn't compiling! Use your knowledge of generics to
+// fix it.
+//
+// Execute `rustlings hint generics1` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let mut shopping_list: Vec<&str> = Vec::new();
shopping_list.push("milk");
}
-
diff --git a/exercises/generics/generics2.rs b/exercises/generics/generics2.rs
index ad69c588..6f7a2612 100644
--- a/exercises/generics/generics2.rs
+++ b/exercises/generics/generics2.rs
@@ -1,9 +1,22 @@
+// generics2.rs
+//
// This powerful wrapper provides the ability to store a positive integer value.
// Rewrite it using generics so that it supports wrapping ANY type.
+//
+// Execute `rustlings hint generics2` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
struct Wrapper {
value: T
}
+=======
+// I AM NOT DONE
+
+struct Wrapper {
+ value: u32,
+}
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
impl Wrapper {
pub fn new(value: T) -> Self {
@@ -17,11 +30,11 @@ mod tests {
#[test]
fn store_u32_in_wrapper() {
- assert_eq!(Wrapper::new(42).value, 42);
+ assert_eq!(Wrapper::new(42).value, 42);
}
#[test]
fn store_str_in_wrapper() {
assert_eq!(Wrapper::new("Foo").value, "Foo");
}
-}
\ No newline at end of file
+}
diff --git a/exercises/hashmaps/README.md b/exercises/hashmaps/README.md
new file mode 100644
index 00000000..80ec1441
--- /dev/null
+++ b/exercises/hashmaps/README.md
@@ -0,0 +1,12 @@
+# Hashmaps
+
+A *hash map* allows you to associate a value with a particular key.
+You may also know this by the names [*unordered map* in C++](https://en.cppreference.com/w/cpp/container/unordered_map),
+[*dictionary* in Python](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) or an *associative array* in other languages.
+
+This is the other data structure that we've been talking about before, when
+talking about Vecs.
+
+## Further information
+
+- [Storing Keys with Associated Values in Hash Maps](https://doc.rust-lang.org/book/ch08-03-hash-maps.html)
diff --git a/exercises/hashmaps/hashmaps1.rs b/exercises/hashmaps/hashmaps1.rs
new file mode 100644
index 00000000..80829eaa
--- /dev/null
+++ b/exercises/hashmaps/hashmaps1.rs
@@ -0,0 +1,44 @@
+// hashmaps1.rs
+//
+// A basket of fruits in the form of a hash map needs to be defined. The key
+// represents the name of the fruit and the value represents how many of that
+// particular fruit is in the basket. You have to put at least three different
+// types of fruits (e.g apple, banana, mango) in the basket and the total count
+// of all the fruits should be at least five.
+//
+// Make me compile and pass the tests!
+//
+// Execute `rustlings hint hashmaps1` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::collections::HashMap;
+
+fn fruit_basket() -> HashMap {
+ let mut basket = // TODO: declare your hash map here.
+
+ // Two bananas are already given for you :)
+ basket.insert(String::from("banana"), 2);
+
+ // TODO: Put more fruits in your basket here.
+
+ basket
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn at_least_three_types_of_fruits() {
+ let basket = fruit_basket();
+ assert!(basket.len() >= 3);
+ }
+
+ #[test]
+ fn at_least_five_fruits() {
+ let basket = fruit_basket();
+ assert!(basket.values().sum::() >= 5);
+ }
+}
diff --git a/exercises/hashmaps/hashmaps2.rs b/exercises/hashmaps/hashmaps2.rs
new file mode 100644
index 00000000..a5925690
--- /dev/null
+++ b/exercises/hashmaps/hashmaps2.rs
@@ -0,0 +1,93 @@
+// hashmaps2.rs
+//
+// We're collecting different fruits to bake a delicious fruit cake. For this,
+// we have a basket, which we'll represent in the form of a hash map. The key
+// represents the name of each fruit we collect and the value represents how
+// many of that particular fruit we have collected. Three types of fruits -
+// Apple (4), Mango (2) and Lychee (5) are already in the basket hash map. You
+// must add fruit to the basket so that there is at least one of each kind and
+// more than 11 in total - we have a lot of mouths to feed. You are not allowed
+// to insert any more of these fruits!
+//
+// Make me pass the tests!
+//
+// Execute `rustlings hint hashmaps2` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::collections::HashMap;
+
+#[derive(Hash, PartialEq, Eq)]
+enum Fruit {
+ Apple,
+ Banana,
+ Mango,
+ Lychee,
+ Pineapple,
+}
+
+fn fruit_basket(basket: &mut HashMap) {
+ let fruit_kinds = vec![
+ Fruit::Apple,
+ Fruit::Banana,
+ Fruit::Mango,
+ Fruit::Lychee,
+ Fruit::Pineapple,
+ ];
+
+ for fruit in fruit_kinds {
+ // TODO: Insert new fruits if they are not already present in the
+ // basket. Note that you are not allowed to put any type of fruit that's
+ // already present!
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ // Don't modify this function!
+ fn get_fruit_basket() -> HashMap {
+ let mut basket = HashMap::::new();
+ basket.insert(Fruit::Apple, 4);
+ basket.insert(Fruit::Mango, 2);
+ basket.insert(Fruit::Lychee, 5);
+
+ basket
+ }
+
+ #[test]
+ fn test_given_fruits_are_not_modified() {
+ let mut basket = get_fruit_basket();
+ fruit_basket(&mut basket);
+ assert_eq!(*basket.get(&Fruit::Apple).unwrap(), 4);
+ assert_eq!(*basket.get(&Fruit::Mango).unwrap(), 2);
+ assert_eq!(*basket.get(&Fruit::Lychee).unwrap(), 5);
+ }
+
+ #[test]
+ fn at_least_five_types_of_fruits() {
+ let mut basket = get_fruit_basket();
+ fruit_basket(&mut basket);
+ let count_fruit_kinds = basket.len();
+ assert!(count_fruit_kinds >= 5);
+ }
+
+ #[test]
+ fn greater_than_eleven_fruits() {
+ let mut basket = get_fruit_basket();
+ fruit_basket(&mut basket);
+ let count = basket.values().sum::();
+ assert!(count > 11);
+ }
+
+ #[test]
+ fn all_fruit_types_in_basket() {
+ let mut basket = get_fruit_basket();
+ fruit_basket(&mut basket);
+ for amount in basket.values() {
+ assert_ne!(amount, &0);
+ }
+ }
+}
diff --git a/exercises/hashmaps/hashmaps3.rs b/exercises/hashmaps/hashmaps3.rs
new file mode 100644
index 00000000..08e977c3
--- /dev/null
+++ b/exercises/hashmaps/hashmaps3.rs
@@ -0,0 +1,86 @@
+// hashmaps3.rs
+//
+// A list of scores (one per line) of a soccer match is given. Each line is of
+// the form : ",,,"
+// Example: England,France,4,2 (England scored 4 goals, France 2).
+//
+// You have to build a scores table containing the name of the team, goals the
+// team scored, and goals the team conceded. One approach to build the scores
+// table is to use a Hashmap. The solution is partially written to use a
+// Hashmap, complete it to pass the test.
+//
+// Make me pass the tests!
+//
+// Execute `rustlings hint hashmaps3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::collections::HashMap;
+
+// A structure to store the goal details of a team.
+struct Team {
+ goals_scored: u8,
+ goals_conceded: u8,
+}
+
+fn build_scores_table(results: String) -> HashMap {
+ // The name of the team is the key and its associated struct is the value.
+ let mut scores: HashMap = HashMap::new();
+
+ for r in results.lines() {
+ let v: Vec<&str> = r.split(',').collect();
+ let team_1_name = v[0].to_string();
+ let team_1_score: u8 = v[2].parse().unwrap();
+ let team_2_name = v[1].to_string();
+ let team_2_score: u8 = v[3].parse().unwrap();
+ // TODO: Populate the scores table with details extracted from the
+ // current line. Keep in mind that goals scored by team_1
+ // will be the number of goals conceded from team_2, and similarly
+ // goals scored by team_2 will be the number of goals conceded by
+ // team_1.
+ }
+ scores
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ fn get_results() -> String {
+ let results = "".to_string()
+ + "England,France,4,2\n"
+ + "France,Italy,3,1\n"
+ + "Poland,Spain,2,0\n"
+ + "Germany,England,2,1\n";
+ results
+ }
+
+ #[test]
+ fn build_scores() {
+ let scores = build_scores_table(get_results());
+
+ let mut keys: Vec<&String> = scores.keys().collect();
+ keys.sort();
+ assert_eq!(
+ keys,
+ vec!["England", "France", "Germany", "Italy", "Poland", "Spain"]
+ );
+ }
+
+ #[test]
+ fn validate_team_score_1() {
+ let scores = build_scores_table(get_results());
+ let team = scores.get("England").unwrap();
+ assert_eq!(team.goals_scored, 5);
+ assert_eq!(team.goals_conceded, 4);
+ }
+
+ #[test]
+ fn validate_team_score_2() {
+ let scores = build_scores_table(get_results());
+ let team = scores.get("Spain").unwrap();
+ assert_eq!(team.goals_scored, 0);
+ assert_eq!(team.goals_conceded, 2);
+ }
+}
diff --git a/exercises/if/README.md b/exercises/if/README.md
index b1157218..b52c3922 100644
--- a/exercises/if/README.md
+++ b/exercises/if/README.md
@@ -1,7 +1,7 @@
-### If
+# If
-`if`, the most basic type of control flow, is what you'll learn here.
+`if`, the most basic (but still surprisingly versatile!) type of control flow, is what you'll learn here.
-#### Book Sections
+## Further information
- [Control Flow - if expressions](https://doc.rust-lang.org/book/ch03-05-control-flow.html#if-expressions)
diff --git a/exercises/if/if1.rs b/exercises/if/if1.rs
index 452541d2..0999ae5c 100644
--- a/exercises/if/if1.rs
+++ b/exercises/if/if1.rs
@@ -1,16 +1,21 @@
// if1.rs
+//
+// Execute `rustlings hint if1` or use the `hint` watch subcommand for a hint.
pub fn bigger(a: i32, b: i32) -> i32 {
// Complete this function to return the bigger number!
// Do not use:
// - another function call
// - additional variables
+<<<<<<< HEAD
// Execute `rustlings hint if1` for hints
if (a > b) {
return a;
} else {
return b;
}
+=======
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
// Don't mind this for now :)
diff --git a/exercises/if/if2.rs b/exercises/if/if2.rs
index 545083a3..0f1d0e72 100644
--- a/exercises/if/if2.rs
+++ b/exercises/if/if2.rs
@@ -1,10 +1,17 @@
// if2.rs
-
+//
// Step 1: Make me compile!
// Step 2: Get the bar_for_fuzz and default_to_baz tests passing!
-// Execute the command `rustlings hint if2` if you want a hint :)
+//
+// Execute `rustlings hint if2` or use the `hint` watch subcommand for a hint.
+<<<<<<< HEAD
pub fn fizz_if_foo(fizzish: &str) -> &str {
+=======
+// I AM NOT DONE
+
+pub fn foo_if_fizz(fizzish: &str) -> &str {
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
if fizzish == "fizz" {
"foo"
} else if fizzish == "fuzz" {
@@ -21,16 +28,16 @@ mod tests {
#[test]
fn foo_for_fizz() {
- assert_eq!(fizz_if_foo("fizz"), "foo")
+ assert_eq!(foo_if_fizz("fizz"), "foo")
}
#[test]
fn bar_for_fuzz() {
- assert_eq!(fizz_if_foo("fuzz"), "bar")
+ assert_eq!(foo_if_fizz("fuzz"), "bar")
}
#[test]
fn default_to_baz() {
- assert_eq!(fizz_if_foo("literally anything"), "baz")
+ assert_eq!(foo_if_fizz("literally anything"), "baz")
}
}
diff --git a/exercises/if/if3.rs b/exercises/if/if3.rs
new file mode 100644
index 00000000..73a7025b
--- /dev/null
+++ b/exercises/if/if3.rs
@@ -0,0 +1,55 @@
+// if3.rs
+//
+// Execute `rustlings hint if3` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+pub fn animal_habitat(animal: &str) -> &'static str {
+ let identifier = if animal == "crab" {
+ 1
+ } else if animal == "gopher" {
+ 2.0
+ } else if animal == "snake" {
+ 3
+ } else {
+ "Unknown"
+ };
+
+ // DO NOT CHANGE THIS STATEMENT BELOW
+ let habitat = if identifier == 1 {
+ "Beach"
+ } else if identifier == 2 {
+ "Burrow"
+ } else if identifier == 3 {
+ "Desert"
+ } else {
+ "Unknown"
+ };
+
+ habitat
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn gopher_lives_in_burrow() {
+ assert_eq!(animal_habitat("gopher"), "Burrow")
+ }
+
+ #[test]
+ fn snake_lives_in_desert() {
+ assert_eq!(animal_habitat("snake"), "Desert")
+ }
+
+ #[test]
+ fn crab_lives_on_beach() {
+ assert_eq!(animal_habitat("crab"), "Beach")
+ }
+
+ #[test]
+ fn unknown_animal() {
+ assert_eq!(animal_habitat("dinosaur"), "Unknown")
+ }
+}
diff --git a/exercises/intro/README.md b/exercises/intro/README.md
new file mode 100644
index 00000000..d32e4a8b
--- /dev/null
+++ b/exercises/intro/README.md
@@ -0,0 +1,8 @@
+# Intro
+
+Rust uses the `print!` and `println!` macros to print text to the console.
+
+## Further information
+
+- [Hello World](https://doc.rust-lang.org/rust-by-example/hello.html)
+- [Formatted print](https://doc.rust-lang.org/rust-by-example/hello/print.html)
diff --git a/exercises/intro/intro1.rs b/exercises/intro/intro1.rs
new file mode 100644
index 00000000..37fa0112
--- /dev/null
+++ b/exercises/intro/intro1.rs
@@ -0,0 +1,41 @@
+// intro1.rs
+//
+// About this `I AM NOT DONE` thing:
+// We sometimes encourage you to keep trying things on a given exercise, even
+// after you already figured it out. If you got everything working and feel
+// ready for the next exercise, remove the `I AM NOT DONE` comment below.
+//
+// If you're running this using `rustlings watch`: The exercise file will be
+// reloaded when you change one of the lines below! Try adding a `println!`
+// line, or try changing what it outputs in your terminal. Try removing a
+// semicolon and see what happens!
+//
+// Execute `rustlings hint intro1` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+fn main() {
+ println!("Hello and");
+ println!(r#" welcome to... "#);
+ println!(r#" _ _ _ "#);
+ println!(r#" _ __ _ _ ___| |_| (_)_ __ __ _ ___ "#);
+ println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
+ println!(r#" | | | |_| \__ \ |_| | | | | | (_| \__ \ "#);
+ println!(r#" |_| \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
+ println!(r#" |___/ "#);
+ println!();
+ println!("This exercise compiles successfully. The remaining exercises contain a compiler");
+ println!("or logic error. The central concept behind Rustlings is to fix these errors and");
+ println!("solve the exercises. Good luck!");
+ println!();
+ println!("The source for this exercise is in `exercises/intro/intro1.rs`. Have a look!");
+ println!(
+ "Going forward, the source of the exercises will always be in the success/failure output."
+ );
+ println!();
+ println!(
+ "If you want to use rust-analyzer, Rust's LSP implementation, make sure your editor is set"
+ );
+ println!("up, and then run `rustlings lsp` before continuing.")
+}
diff --git a/exercises/intro/intro2.rs b/exercises/intro/intro2.rs
new file mode 100644
index 00000000..990b20f0
--- /dev/null
+++ b/exercises/intro/intro2.rs
@@ -0,0 +1,12 @@
+// intro2.rs
+//
+// Make the code print a greeting to the world.
+//
+// Execute `rustlings hint intro2` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+fn main() {
+ println!("Hello {}!");
+}
diff --git a/exercises/iterators/README.md b/exercises/iterators/README.md
new file mode 100644
index 00000000..0e8b671e
--- /dev/null
+++ b/exercises/iterators/README.md
@@ -0,0 +1,8 @@
+# Iterators
+
+This section will teach you about Iterators.
+
+## Further information
+
+- [Iterator](https://doc.rust-lang.org/book/ch13-02-iterators.html)
+- [Iterator documentation](https://doc.rust-lang.org/stable/std/iter/)
diff --git a/exercises/iterators/iterators1.rs b/exercises/iterators/iterators1.rs
new file mode 100644
index 00000000..b3f698be
--- /dev/null
+++ b/exercises/iterators/iterators1.rs
@@ -0,0 +1,25 @@
+// iterators1.rs
+//
+// When performing operations on elements within a collection, iterators are
+// essential. This module helps you get familiar with the structure of using an
+// iterator and how to go through elements within an iterable collection.
+//
+// Make me compile by filling in the `???`s
+//
+// Execute `rustlings hint iterators1` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+fn main() {
+ let my_fav_fruits = vec!["banana", "custard apple", "avocado", "peach", "raspberry"];
+
+ let mut my_iterable_fav_fruits = ???; // TODO: Step 1
+
+ assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));
+ assert_eq!(my_iterable_fav_fruits.next(), ???); // TODO: Step 2
+ assert_eq!(my_iterable_fav_fruits.next(), Some(&"avocado"));
+ assert_eq!(my_iterable_fav_fruits.next(), ???); // TODO: Step 3
+ assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));
+ assert_eq!(my_iterable_fav_fruits.next(), ???); // TODO: Step 4
+}
diff --git a/exercises/iterators/iterators2.rs b/exercises/iterators/iterators2.rs
new file mode 100644
index 00000000..dda82a08
--- /dev/null
+++ b/exercises/iterators/iterators2.rs
@@ -0,0 +1,63 @@
+// iterators2.rs
+//
+// In this exercise, you'll learn some of the unique advantages that iterators
+// can offer. Follow the steps to complete the exercise.
+//
+// Execute `rustlings hint iterators2` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+// Step 1.
+// Complete the `capitalize_first` function.
+// "hello" -> "Hello"
+pub fn capitalize_first(input: &str) -> String {
+ let mut c = input.chars();
+ match c.next() {
+ None => String::new(),
+ Some(first) => ???,
+ }
+}
+
+// Step 2.
+// Apply the `capitalize_first` function to a slice of string slices.
+// Return a vector of strings.
+// ["hello", "world"] -> ["Hello", "World"]
+pub fn capitalize_words_vector(words: &[&str]) -> Vec {
+ vec![]
+}
+
+// Step 3.
+// Apply the `capitalize_first` function again to a slice of string slices.
+// Return a single string.
+// ["hello", " ", "world"] -> "Hello World"
+pub fn capitalize_words_string(words: &[&str]) -> String {
+ String::new()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_success() {
+ assert_eq!(capitalize_first("hello"), "Hello");
+ }
+
+ #[test]
+ fn test_empty() {
+ assert_eq!(capitalize_first(""), "");
+ }
+
+ #[test]
+ fn test_iterate_string_vec() {
+ let words = vec!["hello", "world"];
+ assert_eq!(capitalize_words_vector(&words), ["Hello", "World"]);
+ }
+
+ #[test]
+ fn test_iterate_into_string() {
+ let words = vec!["hello", " ", "world"];
+ assert_eq!(capitalize_words_string(&words), "Hello World");
+ }
+}
diff --git a/exercises/iterators/iterators3.rs b/exercises/iterators/iterators3.rs
new file mode 100644
index 00000000..29fa23a3
--- /dev/null
+++ b/exercises/iterators/iterators3.rs
@@ -0,0 +1,90 @@
+// iterators3.rs
+//
+// This is a bigger exercise than most of the others! You can do it! Here is
+// your mission, should you choose to accept it:
+// 1. Complete the divide function to get the first four tests to pass.
+// 2. Get the remaining tests to pass by completing the result_with_list and
+// list_of_results functions.
+//
+// Execute `rustlings hint iterators3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum DivisionError {
+ NotDivisible(NotDivisibleError),
+ DivideByZero,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct NotDivisibleError {
+ dividend: i32,
+ divisor: i32,
+}
+
+// Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
+// Otherwise, return a suitable error.
+pub fn divide(a: i32, b: i32) -> Result {
+ todo!();
+}
+
+// Complete the function and return a value of the correct type so the test
+// passes.
+// Desired output: Ok([1, 11, 1426, 3])
+fn result_with_list() -> () {
+ let numbers = vec![27, 297, 38502, 81];
+ let division_results = numbers.into_iter().map(|n| divide(n, 27));
+}
+
+// Complete the function and return a value of the correct type so the test
+// passes.
+// Desired output: [Ok(1), Ok(11), Ok(1426), Ok(3)]
+fn list_of_results() -> () {
+ let numbers = vec![27, 297, 38502, 81];
+ let division_results = numbers.into_iter().map(|n| divide(n, 27));
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_success() {
+ assert_eq!(divide(81, 9), Ok(9));
+ }
+
+ #[test]
+ fn test_not_divisible() {
+ assert_eq!(
+ divide(81, 6),
+ Err(DivisionError::NotDivisible(NotDivisibleError {
+ dividend: 81,
+ divisor: 6
+ }))
+ );
+ }
+
+ #[test]
+ fn test_divide_by_0() {
+ assert_eq!(divide(81, 0), Err(DivisionError::DivideByZero));
+ }
+
+ #[test]
+ fn test_divide_0_by_something() {
+ assert_eq!(divide(0, 81), Ok(0));
+ }
+
+ #[test]
+ fn test_result_with_list() {
+ assert_eq!(format!("{:?}", result_with_list()), "Ok([1, 11, 1426, 3])");
+ }
+
+ #[test]
+ fn test_list_of_results() {
+ assert_eq!(
+ format!("{:?}", list_of_results()),
+ "[Ok(1), Ok(11), Ok(1426), Ok(3)]"
+ );
+ }
+}
diff --git a/exercises/standard_library_types/iterators4.rs b/exercises/iterators/iterators4.rs
similarity index 82%
rename from exercises/standard_library_types/iterators4.rs
rename to exercises/iterators/iterators4.rs
index e1e4de5b..6131fefd 100644
--- a/exercises/standard_library_types/iterators4.rs
+++ b/exercises/iterators/iterators4.rs
@@ -1,4 +1,7 @@
// iterators4.rs
+//
+// Execute `rustlings hint iterators4` or use the `hint` watch subcommand for a
+// hint.
pub fn factorial(num: u64) -> u64 {
// Complete this function to return the factorial of num
@@ -25,6 +28,11 @@ pub fn factorial(num: u64) -> u64 {
mod tests {
use super::*;
+ #[test]
+ fn factorial_of_0() {
+ assert_eq!(1, factorial(0));
+ }
+
#[test]
fn factorial_of_1() {
assert_eq!(1, factorial(1));
diff --git a/exercises/iterators/iterators5.rs b/exercises/iterators/iterators5.rs
new file mode 100644
index 00000000..a062ee4c
--- /dev/null
+++ b/exercises/iterators/iterators5.rs
@@ -0,0 +1,156 @@
+// iterators5.rs
+//
+// Let's define a simple model to track Rustlings exercise progress. Progress
+// will be modelled using a hash map. The name of the exercise is the key and
+// the progress is the value. Two counting functions were created to count the
+// number of exercises with a given progress. Recreate this counting
+// functionality using iterators. Try not to use imperative loops (for, while).
+// Only the two iterator methods (count_iterator and count_collection_iterator)
+// need to be modified.
+//
+// Execute `rustlings hint iterators5` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::collections::HashMap;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Progress {
+ None,
+ Some,
+ Complete,
+}
+
+fn count_for(map: &HashMap, value: Progress) -> usize {
+ let mut count = 0;
+ for val in map.values() {
+ if val == &value {
+ count += 1;
+ }
+ }
+ count
+}
+
+fn count_iterator(map: &HashMap, value: Progress) -> usize {
+ // map is a hashmap with String keys and Progress values.
+ // map = { "variables1": Complete, "from_str": None, ... }
+ todo!();
+}
+
+fn count_collection_for(collection: &[HashMap], value: Progress) -> usize {
+ let mut count = 0;
+ for map in collection {
+ for val in map.values() {
+ if val == &value {
+ count += 1;
+ }
+ }
+ }
+ count
+}
+
+fn count_collection_iterator(collection: &[HashMap], value: Progress) -> usize {
+ // collection is a slice of hashmaps.
+ // collection = [{ "variables1": Complete, "from_str": None, ... },
+ // { "variables2": Complete, ... }, ... ]
+ todo!();
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn count_complete() {
+ let map = get_map();
+ assert_eq!(3, count_iterator(&map, Progress::Complete));
+ }
+
+ #[test]
+ fn count_some() {
+ let map = get_map();
+ assert_eq!(1, count_iterator(&map, Progress::Some));
+ }
+
+ #[test]
+ fn count_none() {
+ let map = get_map();
+ assert_eq!(2, count_iterator(&map, Progress::None));
+ }
+
+ #[test]
+ fn count_complete_equals_for() {
+ let map = get_map();
+ let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
+ for progress_state in progress_states {
+ assert_eq!(
+ count_for(&map, progress_state),
+ count_iterator(&map, progress_state)
+ );
+ }
+ }
+
+ #[test]
+ fn count_collection_complete() {
+ let collection = get_vec_map();
+ assert_eq!(
+ 6,
+ count_collection_iterator(&collection, Progress::Complete)
+ );
+ }
+
+ #[test]
+ fn count_collection_some() {
+ let collection = get_vec_map();
+ assert_eq!(1, count_collection_iterator(&collection, Progress::Some));
+ }
+
+ #[test]
+ fn count_collection_none() {
+ let collection = get_vec_map();
+ assert_eq!(4, count_collection_iterator(&collection, Progress::None));
+ }
+
+ #[test]
+ fn count_collection_equals_for() {
+ let progress_states = vec![Progress::Complete, Progress::Some, Progress::None];
+ let collection = get_vec_map();
+
+ for progress_state in progress_states {
+ assert_eq!(
+ count_collection_for(&collection, progress_state),
+ count_collection_iterator(&collection, progress_state)
+ );
+ }
+ }
+
+ fn get_map() -> HashMap {
+ use Progress::*;
+
+ let mut map = HashMap::new();
+ map.insert(String::from("variables1"), Complete);
+ map.insert(String::from("functions1"), Complete);
+ map.insert(String::from("hashmap1"), Complete);
+ map.insert(String::from("arc1"), Some);
+ map.insert(String::from("as_ref_mut"), None);
+ map.insert(String::from("from_str"), None);
+
+ map
+ }
+
+ fn get_vec_map() -> Vec> {
+ use Progress::*;
+
+ let map = get_map();
+
+ let mut other = HashMap::new();
+ other.insert(String::from("variables2"), Complete);
+ other.insert(String::from("functions2"), Complete);
+ other.insert(String::from("if1"), Complete);
+ other.insert(String::from("from_into"), None);
+ other.insert(String::from("try_from_into"), None);
+
+ vec![map, other]
+ }
+}
diff --git a/exercises/lifetimes/README.md b/exercises/lifetimes/README.md
new file mode 100644
index 00000000..91373f73
--- /dev/null
+++ b/exercises/lifetimes/README.md
@@ -0,0 +1,22 @@
+# 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.
+
+If you'd like to learn more about lifetime annotations, the
+[lifetimekata](https://tfpk.github.io/lifetimekata/) project
+has a similar style of exercises to Rustlings, but is all about
+learning to write lifetime annotations.
+
+## Further information
+
+- [Lifetimes (in Rust By Example)](https://doc.rust-lang.org/stable/rust-by-example/scope/lifetime.html)
+- [Validating References with Lifetimes](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html)
diff --git a/exercises/lifetimes/lifetimes1.rs b/exercises/lifetimes/lifetimes1.rs
new file mode 100644
index 00000000..87bde490
--- /dev/null
+++ b/exercises/lifetimes/lifetimes1.rs
@@ -0,0 +1,27 @@
+// 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 00000000..4f3d8c18
--- /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 00000000..9c59f9c0
--- /dev/null
+++ b/exercises/lifetimes/lifetimes3.rs
@@ -0,0 +1,21 @@
+// 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/exercises/macros/README.md b/exercises/macros/README.md
index b48b880a..337816d6 100644
--- a/exercises/macros/README.md
+++ b/exercises/macros/README.md
@@ -1,10 +1,14 @@
-### Macros
+# Macros
Rust's macro system is very powerful, but also kind of difficult to wrap your
head around. We're not going to teach you how to write your own fully-featured
macros. Instead, we'll show you how to use and create them.
-#### Book Sections
+If you'd like to learn more about writing your own macros, the
+[macrokata](https://github.com/tfpk/macrokata) project has a similar style
+of exercises to Rustlings, but is all about learning to write Macros.
+
+## Further information
- [Macros](https://doc.rust-lang.org/book/ch19-06-macros.html)
-- [The Little Book of Rust Macros](https://danielkeep.github.io/tlborm/book/index.html)
+- [The Little Book of Rust Macros](https://veykril.github.io/tlborm/)
diff --git a/exercises/macros/macros1.rs b/exercises/macros/macros1.rs
index de2584a5..9d0edee3 100644
--- a/exercises/macros/macros1.rs
+++ b/exercises/macros/macros1.rs
@@ -1,5 +1,7 @@
// macros1.rs
-// Make me compile! Execute `rustlings hint macros1` for hints :)
+//
+// Execute `rustlings hint macros1` or use the `hint` watch subcommand for a
+// hint.
macro_rules! my_macro {
() => {
diff --git a/exercises/macros/macros2.rs b/exercises/macros/macros2.rs
index 6583dde6..f94607c6 100644
--- a/exercises/macros/macros2.rs
+++ b/exercises/macros/macros2.rs
@@ -1,5 +1,7 @@
// macros2.rs
-// Make me compile! Execute `rustlings hint macros2` for hints :)
+//
+// Execute `rustlings hint macros2` or use the `hint` watch subcommand for a
+// hint.
fn main() {
my_macro!();
diff --git a/exercises/macros/macros3.rs b/exercises/macros/macros3.rs
index cd5f7ba7..1483b415 100644
--- a/exercises/macros/macros3.rs
+++ b/exercises/macros/macros3.rs
@@ -1,6 +1,9 @@
// macros3.rs
+//
// Make me compile, without taking the macro out of the module!
-// Execute `rustlings hint macros3` for hints :)
+//
+// Execute `rustlings hint macros3` or use the `hint` watch subcommand for a
+// hint.
mod macros {
#[macro_export]
diff --git a/exercises/macros/macros4.rs b/exercises/macros/macros4.rs
index 5608ecc6..e1faab43 100644
--- a/exercises/macros/macros4.rs
+++ b/exercises/macros/macros4.rs
@@ -1,6 +1,14 @@
// macros4.rs
-// Make me compile! Execute `rustlings hint macros4` for hints :)
+//
+// Execute `rustlings hint macros4` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
+=======
+// I AM NOT DONE
+
+#[rustfmt::skip]
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
macro_rules! my_macro {
() => {
println!("Check out my macro!");
diff --git a/exercises/modules/README.md b/exercises/modules/README.md
index bb765106..3dc8a482 100644
--- a/exercises/modules/README.md
+++ b/exercises/modules/README.md
@@ -1,7 +1,7 @@
-### Modules
+# Modules
In this section we'll give you an introduction to Rust's module system.
-#### Book Sections
+## Further information
-- [The Module System](https://doc.rust-lang.org/book/ch07-02-defining-modules-to-control-scope-and-privacy.html)
+- [The Module System](https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html)
diff --git a/exercises/modules/modules1.rs b/exercises/modules/modules1.rs
index 3af7f48d..7365abb9 100644
--- a/exercises/modules/modules1.rs
+++ b/exercises/modules/modules1.rs
@@ -1,8 +1,20 @@
// modules1.rs
-// Make me compile! Execute `rustlings hint modules1` for hints :)
+//
+// Execute `rustlings hint modules1` or use the `hint` watch subcommand for a
+// hint.
mod sausage_factory {
+<<<<<<< HEAD
pub fn make_sausage() {
+=======
+ // Don't let anybody outside of this module see this!
+ fn get_secret_recipe() -> String {
+ String::from("Ginger")
+ }
+
+ fn make_sausage() {
+ get_secret_recipe();
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
println!("sausage!");
}
}
diff --git a/exercises/modules/modules2.rs b/exercises/modules/modules2.rs
index 50a3f080..eb8e2581 100644
--- a/exercises/modules/modules2.rs
+++ b/exercises/modules/modules2.rs
@@ -1,9 +1,21 @@
// modules2.rs
-// Make me compile! Execute `rustlings hint modules2` for hints :)
+//
+// You can bring module paths into scopes and provide new names for them with
+// the 'use' and 'as' keywords. Fix these 'use' statements to make the code
+// compile.
+//
+// Execute `rustlings hint modules2` or use the `hint` watch subcommand for a
+// hint.
mod delicious_snacks {
+<<<<<<< HEAD
pub use self::fruits::PEAR as fruit;
pub use self::veggies::CUCUMBER as veggie;
+=======
+ // TODO: Fix these use statements
+ use self::fruits::PEAR as ???
+ use self::veggies::CUCUMBER as ???
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
mod fruits {
pub const PEAR: &'static str = "Pear";
diff --git a/exercises/modules/modules3.rs b/exercises/modules/modules3.rs
new file mode 100644
index 00000000..f2bb0503
--- /dev/null
+++ b/exercises/modules/modules3.rs
@@ -0,0 +1,21 @@
+// modules3.rs
+//
+// You can use the 'use' keyword to bring module paths from modules from
+// anywhere and especially from the Rust standard library into your scope. Bring
+// SystemTime and UNIX_EPOCH from the std::time module. Bonus style points if
+// you can do it with one line!
+//
+// Execute `rustlings hint modules3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+// TODO: Complete this use statement
+use ???
+
+fn main() {
+ match SystemTime::now().duration_since(UNIX_EPOCH) {
+ Ok(n) => println!("1970-01-01 00:00:00 UTC was {} seconds ago!", n.as_secs()),
+ Err(_) => panic!("SystemTime before UNIX EPOCH!"),
+ }
+}
diff --git a/exercises/move_semantics/README.md b/exercises/move_semantics/README.md
index 6842af7c..54ddd8e6 100644
--- a/exercises/move_semantics/README.md
+++ b/exercises/move_semantics/README.md
@@ -1,8 +1,8 @@
-### Move Semantics
+# Move Semantics
These exercises are adapted from [pnkfelix](https://github.com/pnkfelix)'s [Rust Tutorial](https://pnkfelix.github.io/rust-examples-icfp2014/) -- Thank you Felix!!!
-#### Book Sections
+## Further information
For this section, the book links are especially important.
diff --git a/exercises/move_semantics/move_semantics1.rs b/exercises/move_semantics/move_semantics1.rs
index a95f851a..eac7d31b 100644
--- a/exercises/move_semantics/move_semantics1.rs
+++ b/exercises/move_semantics/move_semantics1.rs
@@ -1,5 +1,7 @@
// move_semantics1.rs
-// Make me compile! Execute `rustlings hint move_semantics1` for hints :)
+//
+// Execute `rustlings hint move_semantics1` or use the `hint` watch subcommand
+// for a hint.
fn main() {
let vec0 = Vec::new();
diff --git a/exercises/move_semantics/move_semantics2.rs b/exercises/move_semantics/move_semantics2.rs
index 5579062b..c7b0d9f3 100644
--- a/exercises/move_semantics/move_semantics2.rs
+++ b/exercises/move_semantics/move_semantics2.rs
@@ -1,18 +1,22 @@
// move_semantics2.rs
-// Make me compile without changing line 13!
-// Execute `rustlings hint move_semantics2` for hints :)
+//
+// Expected output:
+// vec0 has length 3, with contents `[22, 44, 66]`
+// vec1 has length 4, with contents `[22, 44, 66, 88]`
+//
+// Execute `rustlings hint move_semantics2` or use the `hint` watch subcommand
+// for a hint.
fn main() {
let vec0 = Vec::new();
let mut vec1 = fill_vec(vec0.clone());
- // Do not change the following line!
- println!("{} has length {} content `{:?}`", "vec0", vec0.len(), vec0);
+ println!("{} has length {}, with contents: `{:?}`", "vec0", vec0.len(), vec0);
vec1.push(88);
- println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
+ println!("{} has length {}, with contents `{:?}`", "vec1", vec1.len(), vec1);
}
fn fill_vec(vec: Vec) -> Vec {
diff --git a/exercises/move_semantics/move_semantics3.rs b/exercises/move_semantics/move_semantics3.rs
index 02356426..65b64ce4 100644
--- a/exercises/move_semantics/move_semantics3.rs
+++ b/exercises/move_semantics/move_semantics3.rs
@@ -1,7 +1,10 @@
// move_semantics3.rs
-// Make me compile without adding new lines-- just changing existing lines!
-// (no lines with multiple semicolons necessary!)
-// Execute `rustlings hint move_semantics3` for hints :)
+//
+// Make me compile without adding new lines-- just changing existing lines! (no
+// lines with multiple semicolons necessary!)
+//
+// Execute `rustlings hint move_semantics3` or use the `hint` watch subcommand
+// for a hint.
fn main() {
let mut vec0 = Vec::new();
diff --git a/exercises/move_semantics/move_semantics4.rs b/exercises/move_semantics/move_semantics4.rs
index e6e780b3..12d47f99 100644
--- a/exercises/move_semantics/move_semantics4.rs
+++ b/exercises/move_semantics/move_semantics4.rs
@@ -1,8 +1,11 @@
// move_semantics4.rs
-// Refactor this code so that instead of having `vec0` and creating the vector
-// in `fn main`, we instead create it within `fn fill_vec` and transfer the
-// freshly created vector from fill_vec to its caller.
-// Execute `rustlings hint move_semantics4` for hints!
+//
+// Refactor this code so that instead of passing `vec0` into the `fill_vec`
+// function, the Vector gets created in the function itself and passed back to
+// the main function.
+//
+// Execute `rustlings hint move_semantics4` or use the `hint` watch subcommand
+// for a hint.
fn main() {
let mut vec1 = fill_vec();
@@ -14,7 +17,7 @@ fn main() {
println!("{} has length {} content `{:?}`", "vec1", vec1.len(), vec1);
}
-// `fill_vec()` no longer take `vec: Vec` as argument
+// `fill_vec()` no longer takes `vec: Vec` as argument
fn fill_vec() -> Vec {
let mut vec = Vec::new();
diff --git a/exercises/move_semantics/move_semantics5.rs b/exercises/move_semantics/move_semantics5.rs
new file mode 100644
index 00000000..68db09eb
--- /dev/null
+++ b/exercises/move_semantics/move_semantics5.rs
@@ -0,0 +1,18 @@
+// move_semantics5.rs
+//
+// Make me compile only by reordering the lines in `main()`, but without adding,
+// changing or removing any of them.
+//
+// Execute `rustlings hint move_semantics5` or use the `hint` watch subcommand
+// for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+ let mut x = 100;
+ let y = &mut x;
+ let z = &mut x;
+ *y += 100;
+ *z += 1000;
+ assert_eq!(x, 1200);
+}
diff --git a/exercises/move_semantics/move_semantics6.rs b/exercises/move_semantics/move_semantics6.rs
new file mode 100644
index 00000000..cace4ca6
--- /dev/null
+++ b/exercises/move_semantics/move_semantics6.rs
@@ -0,0 +1,28 @@
+// move_semantics6.rs
+//
+// You can't change anything except adding or removing references.
+//
+// Execute `rustlings hint move_semantics6` or use the `hint` watch subcommand
+// for a hint.
+
+// I AM NOT DONE
+
+fn main() {
+ let data = "Rust is great!".to_string();
+
+ get_char(data);
+
+ string_uppercase(&data);
+}
+
+// Should not take ownership
+fn get_char(data: String) -> char {
+ data.chars().last().unwrap()
+}
+
+// Should take ownership
+fn string_uppercase(mut data: &String) {
+ data = &data.to_uppercase();
+
+ println!("{}", data);
+}
diff --git a/exercises/option/README.md b/exercises/option/README.md
deleted file mode 100644
index d17b79cc..00000000
--- a/exercises/option/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-### Option
-
-#### Book Sections
-
-To learn about Option, check out these links:
-
-- [Option Enum Format](https://doc.rust-lang.org/stable/book/ch10-01-syntax.html#in-enum-definitions)
-- [Option Module Documentation](https://doc.rust-lang.org/std/option/)
-- [Option Enum Documentation](https://doc.rust-lang.org/std/option/enum.Option.html)
diff --git a/exercises/options/README.md b/exercises/options/README.md
new file mode 100644
index 00000000..bdd33749
--- /dev/null
+++ b/exercises/options/README.md
@@ -0,0 +1,21 @@
+# Options
+
+Type Option represents an optional value: every Option is either Some and contains a value, or None, and does not.
+Option types are very common in Rust code, as they have a number of uses:
+
+- Initial values
+- Return values for functions that are not defined over their entire input range (partial functions)
+- Return value for otherwise reporting simple errors, where None is returned on error
+- Optional struct fields
+- Struct fields that can be loaned or "taken"
+- Optional function arguments
+- Nullable pointers
+- Swapping things out of difficult situations
+
+## Further Information
+
+- [Option Enum Format](https://doc.rust-lang.org/stable/book/ch10-01-syntax.html#in-enum-definitions)
+- [Option Module Documentation](https://doc.rust-lang.org/std/option/)
+- [Option Enum Documentation](https://doc.rust-lang.org/std/option/enum.Option.html)
+- [if let](https://doc.rust-lang.org/rust-by-example/flow_control/if_let.html)
+- [while let](https://doc.rust-lang.org/rust-by-example/flow_control/while_let.html)
diff --git a/exercises/options/options1.rs b/exercises/options/options1.rs
new file mode 100644
index 00000000..e131b48b
--- /dev/null
+++ b/exercises/options/options1.rs
@@ -0,0 +1,39 @@
+// options1.rs
+//
+// Execute `rustlings hint options1` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+// This function returns how much icecream there is left in the fridge.
+// If it's before 10PM, there's 5 pieces left. At 10PM, someone eats them
+// all, so there'll be no more left :(
+fn maybe_icecream(time_of_day: u16) -> Option {
+ // We use the 24-hour system here, so 10PM is a value of 22 and 12AM is a
+ // value of 0 The Option output should gracefully handle cases where
+ // time_of_day > 23.
+ // TODO: Complete the function body - remember to return an Option!
+ ???
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn check_icecream() {
+ assert_eq!(maybe_icecream(9), Some(5));
+ assert_eq!(maybe_icecream(10), Some(5));
+ assert_eq!(maybe_icecream(23), Some(0));
+ assert_eq!(maybe_icecream(22), Some(0));
+ assert_eq!(maybe_icecream(25), None);
+ }
+
+ #[test]
+ fn raw_value() {
+ // TODO: Fix this test. How do you get at the value contained in the
+ // Option?
+ let icecreams = maybe_icecream(12);
+ assert_eq!(icecreams, 5);
+ }
+}
diff --git a/exercises/options/options2.rs b/exercises/options/options2.rs
new file mode 100644
index 00000000..4d998e7d
--- /dev/null
+++ b/exercises/options/options2.rs
@@ -0,0 +1,42 @@
+// options2.rs
+//
+// Execute `rustlings hint options2` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+#[cfg(test)]
+mod tests {
+ #[test]
+ fn simple_option() {
+ let target = "rustlings";
+ let optional_target = Some(target);
+
+ // TODO: Make this an if let statement whose value is "Some" type
+ word = optional_target {
+ assert_eq!(word, target);
+ }
+ }
+
+ #[test]
+ fn layered_option() {
+ let range = 10;
+ let mut optional_integers: Vec> = vec![None];
+
+ for i in 1..(range + 1) {
+ optional_integers.push(Some(i));
+ }
+
+ let mut cursor = range;
+
+ // TODO: make this a while let statement - remember that vector.pop also
+ // adds another layer of Option. You can stack `Option`s into
+ // while let and if let.
+ integer = optional_integers.pop() {
+ assert_eq!(integer, cursor);
+ cursor -= 1;
+ }
+
+ assert_eq!(cursor, 0);
+ }
+}
diff --git a/exercises/options/options3.rs b/exercises/options/options3.rs
new file mode 100644
index 00000000..23c15eab
--- /dev/null
+++ b/exercises/options/options3.rs
@@ -0,0 +1,21 @@
+// options3.rs
+//
+// Execute `rustlings hint options3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+struct Point {
+ x: i32,
+ y: i32,
+}
+
+fn main() {
+ let y: Option = Some(Point { x: 100, y: 200 });
+
+ match y {
+ Some(p) => println!("Co-ordinates are {},{} ", p.x, p.y),
+ _ => panic!("no match!"),
+ }
+ y; // Fix without deleting this line.
+}
diff --git a/exercises/primitive_types/README.md b/exercises/primitive_types/README.md
index daa70eea..cea69b02 100644
--- a/exercises/primitive_types/README.md
+++ b/exercises/primitive_types/README.md
@@ -1,9 +1,9 @@
-### Primitive Types
+# Primitive Types
Rust has a couple of basic types that are directly implemented into the
compiler. In this section, we'll go through the most important ones.
-#### Book Sections
+## Further information
- [Data Types](https://doc.rust-lang.org/stable/book/ch03-02-data-types.html)
- [The Slice Type](https://doc.rust-lang.org/stable/book/ch04-03-slices.html)
diff --git a/exercises/primitive_types/primitive_types1.rs b/exercises/primitive_types/primitive_types1.rs
index 693394e6..d8c09b7b 100644
--- a/exercises/primitive_types/primitive_types1.rs
+++ b/exercises/primitive_types/primitive_types1.rs
@@ -1,6 +1,10 @@
// primitive_types1.rs
-// Fill in the rest of the line that has code missing!
-// No hints, there's no tricks, just get used to typing these :)
+//
+// Fill in the rest of the line that has code missing! No hints, there's no
+// tricks, just get used to typing these :)
+//
+// Execute `rustlings hint primitive_types1` or use the `hint` watch subcommand
+// for a hint.
fn main() {
// Booleans (`bool`)
diff --git a/exercises/primitive_types/primitive_types2.rs b/exercises/primitive_types/primitive_types2.rs
index 060fb528..97693376 100644
--- a/exercises/primitive_types/primitive_types2.rs
+++ b/exercises/primitive_types/primitive_types2.rs
@@ -1,11 +1,21 @@
// primitive_types2.rs
-// Fill in the rest of the line that has code missing!
-// No hints, there's no tricks, just get used to typing these :)
+//
+// Fill in the rest of the line that has code missing! No hints, there's no
+// tricks, just get used to typing these :)
+//
+// Execute `rustlings hint primitive_types2` or use the `hint` watch subcommand
+// for a hint.
fn main() {
// Characters (`char`)
+<<<<<<< HEAD
let my_first_initial: char = 'C';
+=======
+ // Note the _single_ quotes, these are different from the double quotes
+ // you've been seeing around.
+ let my_first_initial = 'C';
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
if my_first_initial.is_alphabetic() {
println!("Alphabetical!");
} else if my_first_initial.is_numeric() {
diff --git a/exercises/primitive_types/primitive_types3.rs b/exercises/primitive_types/primitive_types3.rs
index 814de271..66d78e74 100644
--- a/exercises/primitive_types/primitive_types3.rs
+++ b/exercises/primitive_types/primitive_types3.rs
@@ -1,6 +1,9 @@
// primitive_types3.rs
-// Create an array with at least 100 elements in it where the ??? is.
-// Execute `rustlings hint primitive_types3` for hints!
+//
+// Create an array with at least 100 elements in it where the ??? is.
+//
+// Execute `rustlings hint primitive_types3` or use the `hint` watch subcommand
+// for a hint.
fn main() {
let a = [0;100];
diff --git a/exercises/primitive_types/primitive_types4.rs b/exercises/primitive_types/primitive_types4.rs
index 88efbf50..79cb4272 100644
--- a/exercises/primitive_types/primitive_types4.rs
+++ b/exercises/primitive_types/primitive_types4.rs
@@ -1,6 +1,9 @@
// primitive_types4.rs
+//
// Get a slice out of Array a where the ??? is so that the test passes.
-// Execute `rustlings hint primitive_types4` for hints!!
+//
+// Execute `rustlings hint primitive_types4` or use the `hint` watch subcommand
+// for a hint.
#[test]
fn slice_out_of_array() {
diff --git a/exercises/primitive_types/primitive_types5.rs b/exercises/primitive_types/primitive_types5.rs
index 85f42cfc..7a330445 100644
--- a/exercises/primitive_types/primitive_types5.rs
+++ b/exercises/primitive_types/primitive_types5.rs
@@ -1,6 +1,9 @@
// primitive_types5.rs
+//
// Destructure the `cat` tuple so that the println will work.
-// Execute `rustlings hint primitive_types5` for hints!
+//
+// Execute `rustlings hint primitive_types5` or use the `hint` watch subcommand
+// for a hint.
fn main() {
let cat = ("Furry McFurson", 3.5);
diff --git a/exercises/primitive_types/primitive_types6.rs b/exercises/primitive_types/primitive_types6.rs
index c8d010a3..583394d9 100644
--- a/exercises/primitive_types/primitive_types6.rs
+++ b/exercises/primitive_types/primitive_types6.rs
@@ -1,9 +1,25 @@
// primitive_types6.rs
-// Use a tuple index to access the second element of `numbers`.
-// You can put this right into the `println!` where the ??? is.
-// Execute `rustlings hint primitive_types6` for hints!
+//
+// Use a tuple index to access the second element of `numbers`. You can put the
+// expression for the second element where ??? is so that the test passes.
+//
+// Execute `rustlings hint primitive_types6` or use the `hint` watch subcommand
+// for a hint.
+<<<<<<< HEAD
fn main() {
let numbers = (1, 2, 3);
println!("The second number is {}", numbers.1);
+=======
+// I AM NOT DONE
+
+#[test]
+fn indexing_tuple() {
+ let numbers = (1, 2, 3);
+ // Replace below ??? with the tuple indexing syntax.
+ let second = ???;
+
+ assert_eq!(2, second,
+ "This is not the 2nd number in the tuple!")
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
diff --git a/exercises/quiz1.rs b/exercises/quiz1.rs
index beb37a46..dfad48d8 100644
--- a/exercises/quiz1.rs
+++ b/exercises/quiz1.rs
@@ -1,11 +1,17 @@
// quiz1.rs
+//
// This is a quiz for the following sections:
// - Variables
// - Functions
-
-// Mary is buying apples. One apple usually costs 2 Rustbucks, but if you buy
-// more than 40 at once, each apple only costs 1! Write a function that calculates
-// the price of an order of apples given the order amount. No hints this time!
+// - If
+//
+// Mary is buying apples. The price of an apple is calculated as follows:
+// - An apple costs 2 rustbucks.
+// - If Mary buys more than 40 apples, each apple only costs 1 rustbuck!
+// Write a function that calculates the price of an order of apples given the
+// quantity bought.
+//
+// No hints this time ;)
fn calculate_apple_price(amount: i32) -> i32 {
let mut unitPrice: i32 = 2;
@@ -17,9 +23,13 @@ fn calculate_apple_price(amount: i32) -> i32 {
// Don't modify this function!
#[test]
fn verify_test() {
- let price1 = calculate_apple_price(35);
- let price2 = calculate_apple_price(65);
+ let price1 = calculate_price_of_apples(35);
+ let price2 = calculate_price_of_apples(40);
+ let price3 = calculate_price_of_apples(41);
+ let price4 = calculate_price_of_apples(65);
assert_eq!(70, price1);
- assert_eq!(65, price2);
+ assert_eq!(80, price2);
+ assert_eq!(41, price3);
+ assert_eq!(65, price4);
}
diff --git a/exercises/quiz2.rs b/exercises/quiz2.rs
index 613c1d92..b00823d4 100644
--- a/exercises/quiz2.rs
+++ b/exercises/quiz2.rs
@@ -1,11 +1,24 @@
// quiz2.rs
+//
// This is a quiz for the following sections:
// - Strings
-
-// Ok, here are a bunch of values-- some are `String`s, some are `&str`s. Your
-// task is to call one of these two functions on each value depending on what
-// you think each value is. That is, add either `string_slice` or `string`
-// before the parentheses on each line. If you're right, it will compile!
+// - Vecs
+// - Move semantics
+// - Modules
+// - Enums
+//
+// Let's build a little machine in the form of a function. As input, we're going
+// to give a list of strings and commands. These commands determine what action
+// is going to be applied to the string. It can either be:
+// - Uppercase the string
+// - Trim the string
+// - Append "bar" to the string a specified amount of times
+// The exact form of this will be:
+// - The input is going to be a Vector of a 2-length tuple,
+// the first element is the string, the second one is the command.
+// - The output element is going to be a Vector of strings.
+//
+// No hints this time!
fn string_slice(arg: &str) {
println!("{}", arg);
diff --git a/exercises/quiz3.rs b/exercises/quiz3.rs
index ec86a8e5..1e5f3439 100644
--- a/exercises/quiz3.rs
+++ b/exercises/quiz3.rs
@@ -1,14 +1,39 @@
// quiz3.rs
-// This is a quiz for the following sections:
-// - Tests
-
-// This quiz isn't testing our function -- make it do that in such a way that
-// the test passes. Then write a second test that tests that we get the result
-// we expect to get when we call `times_two` with a negative number.
-// No hints, you can do this :)
+//
+// This quiz tests:
+// - Generics
+// - Traits
+//
+// An imaginary magical school has a new report card generation system written
+// in Rust! Currently the system only supports creating report cards where the
+// student's grade is represented numerically (e.g. 1.0 -> 5.5). However, the
+// school also issues alphabetical grades (A+ -> F-) and needs to be able to
+// print both types of report card!
+//
+// Make the necessary code changes in the struct ReportCard and the impl block
+// to support alphabetical report cards. Change the Grade in the second test to
+// "A+" to show that your changes allow alphabetical grades.
+//
+// Execute `rustlings hint quiz3` or use the `hint` watch subcommand for a hint.
+<<<<<<< HEAD
pub fn times_two(num: i32) -> i32 {
num * 2
+=======
+// I AM NOT DONE
+
+pub struct ReportCard {
+ pub grade: f32,
+ pub student_name: String,
+ pub student_age: u8,
+}
+
+impl ReportCard {
+ pub fn print(&self) -> String {
+ format!("{} ({}) - achieved a grade of {}",
+ &self.student_name, &self.student_age, &self.grade)
+ }
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
#[cfg(test)]
@@ -16,6 +41,7 @@ mod tests {
use super::*;
#[test]
+<<<<<<< HEAD
fn returns_twice_of_positive_numbers() {
assert_eq!(times_two(4), 8);
}
@@ -24,5 +50,31 @@ mod tests {
fn returns_twice_of_negative_numbers() {
// TODO write an assert for `times_two(-4)`
assert_eq!(times_two(-4), -8);
+=======
+ fn generate_numeric_report_card() {
+ let report_card = ReportCard {
+ grade: 2.1,
+ student_name: "Tom Wriggle".to_string(),
+ student_age: 12,
+ };
+ assert_eq!(
+ report_card.print(),
+ "Tom Wriggle (12) - achieved a grade of 2.1"
+ );
+ }
+
+ #[test]
+ fn generate_alphabetic_report_card() {
+ // TODO: Make sure to change the grade here after you finish the exercise.
+ let report_card = ReportCard {
+ grade: 2.1,
+ student_name: "Gary Plotter".to_string(),
+ student_age: 11,
+ };
+ assert_eq!(
+ report_card.print(),
+ "Gary Plotter (11) - achieved a grade of A+"
+ );
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
}
diff --git a/exercises/smart_pointers/README.md b/exercises/smart_pointers/README.md
new file mode 100644
index 00000000..d56d2b62
--- /dev/null
+++ b/exercises/smart_pointers/README.md
@@ -0,0 +1,12 @@
+# Smart Pointers
+
+In Rust, smart pointers are variables that contain an address in memory and reference some other data, but they also have additional metadata and capabilities.
+Smart pointers in Rust often own the data they point to, while references only borrow data.
+
+## Further Information
+
+- [Smart Pointers](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html)
+- [Using Box to Point to Data on the Heap](https://doc.rust-lang.org/book/ch15-01-box.html)
+- [Rc\, the Reference Counted Smart Pointer](https://doc.rust-lang.org/book/ch15-04-rc.html)
+- [Shared-State Concurrency](https://doc.rust-lang.org/book/ch16-03-shared-state.html)
+- [Cow Documentation](https://doc.rust-lang.org/std/borrow/enum.Cow.html)
diff --git a/exercises/smart_pointers/arc1.rs b/exercises/smart_pointers/arc1.rs
new file mode 100644
index 00000000..3526ddcb
--- /dev/null
+++ b/exercises/smart_pointers/arc1.rs
@@ -0,0 +1,45 @@
+// arc1.rs
+//
+// In this exercise, we are given a Vec of u32 called "numbers" with values
+// ranging from 0 to 99 -- [ 0, 1, 2, ..., 98, 99 ] We would like to use this
+// set of numbers within 8 different threads simultaneously. Each thread is
+// going to get the sum of every eighth value, with an offset.
+//
+// The first thread (offset 0), will sum 0, 8, 16, ...
+// The second thread (offset 1), will sum 1, 9, 17, ...
+// The third thread (offset 2), will sum 2, 10, 18, ...
+// ...
+// The eighth thread (offset 7), will sum 7, 15, 23, ...
+//
+// Because we are using threads, our values need to be thread-safe. Therefore,
+// we are using Arc. We need to make a change in each of the two TODOs.
+//
+// Make this code compile by filling in a value for `shared_numbers` where the
+// first TODO comment is, and create an initial binding for `child_numbers`
+// where the second TODO comment is. Try not to create any copies of the
+// `numbers` Vec!
+//
+// Execute `rustlings hint arc1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+#![forbid(unused_imports)] // Do not change this, (or the next) line.
+use std::sync::Arc;
+use std::thread;
+
+fn main() {
+ let numbers: Vec<_> = (0..100u32).collect();
+ let shared_numbers = // TODO
+ let mut joinhandles = Vec::new();
+
+ for offset in 0..8 {
+ let child_numbers = // TODO
+ joinhandles.push(thread::spawn(move || {
+ let sum: u32 = child_numbers.iter().filter(|&&n| n % 8 == offset).sum();
+ println!("Sum of offset {} is {}", offset, sum);
+ }));
+ }
+ for handle in joinhandles.into_iter() {
+ handle.join().unwrap();
+ }
+}
diff --git a/exercises/smart_pointers/box1.rs b/exercises/smart_pointers/box1.rs
new file mode 100644
index 00000000..0ecc628f
--- /dev/null
+++ b/exercises/smart_pointers/box1.rs
@@ -0,0 +1,64 @@
+// box1.rs
+//
+// At compile time, Rust needs to know how much space a type takes up. This
+// becomes problematic for recursive types, where a value can have as part of
+// itself another value of the same type. To get around the issue, we can use a
+// `Box` - a smart pointer used to store data on the heap, which also allows us
+// to wrap a recursive type.
+//
+// The recursive type we're implementing in this exercise is the `cons list` - a
+// data structure frequently found in functional programming languages. Each
+// item in a cons list contains two elements: the value of the current item and
+// the next item. The last item is a value called `Nil`.
+//
+// Step 1: use a `Box` in the enum definition to make the code compile
+// Step 2: create both empty and non-empty cons lists by replacing `todo!()`
+//
+// Note: the tests should not be changed
+//
+// Execute `rustlings hint box1` or use the `hint` watch subcommand for a hint.
+
+#[derive(PartialEq, Debug)]
+pub enum List {
+ Cons(i32, Box),
+ Nil,
+}
+
+fn main() {
+ println!("This is an empty cons list: {:?}", create_empty_list());
+ println!(
+ "This is a non-empty cons list: {:?}",
+ create_non_empty_list()
+ );
+}
+
+pub fn create_empty_list() -> List {
+<<<<<<< HEAD:exercises/standard_library_types/box1.rs
+ List::Nil
+}
+
+pub fn create_non_empty_list() -> List {
+ List::Cons(1, Box::new(List::Nil))
+=======
+ todo!()
+}
+
+pub fn create_non_empty_list() -> List {
+ todo!()
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e:exercises/smart_pointers/box1.rs
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_create_empty_list() {
+ assert_eq!(List::Nil, create_empty_list())
+ }
+
+ #[test]
+ fn test_create_non_empty_list() {
+ assert_ne!(create_empty_list(), create_non_empty_list())
+ }
+}
diff --git a/exercises/smart_pointers/cow1.rs b/exercises/smart_pointers/cow1.rs
new file mode 100644
index 00000000..7ca91686
--- /dev/null
+++ b/exercises/smart_pointers/cow1.rs
@@ -0,0 +1,78 @@
+// cow1.rs
+//
+// This exercise explores the Cow, or Clone-On-Write type. Cow is a
+// clone-on-write smart pointer. It can enclose and provide immutable access to
+// borrowed data, and clone the data lazily when mutation or ownership is
+// required. The type is designed to work with general borrowed data via the
+// Borrow trait.
+//
+// This exercise is meant to show you what to expect when passing data to Cow.
+// Fix the unit tests by checking for Cow::Owned(_) and Cow::Borrowed(_) at the
+// TODO markers.
+//
+// Execute `rustlings hint cow1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+use std::borrow::Cow;
+
+fn abs_all<'a, 'b>(input: &'a mut Cow<'b, [i32]>) -> &'a mut Cow<'b, [i32]> {
+ for i in 0..input.len() {
+ let v = input[i];
+ if v < 0 {
+ // Clones into a vector if not already owned.
+ input.to_mut()[i] = -v;
+ }
+ }
+ input
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn reference_mutation() -> Result<(), &'static str> {
+ // Clone occurs because `input` needs to be mutated.
+ let slice = [-1, 0, 1];
+ let mut input = Cow::from(&slice[..]);
+ match abs_all(&mut input) {
+ Cow::Owned(_) => Ok(()),
+ _ => Err("Expected owned value"),
+ }
+ }
+
+ #[test]
+ fn reference_no_mutation() -> Result<(), &'static str> {
+ // No clone occurs because `input` doesn't need to be mutated.
+ let slice = [0, 1, 2];
+ let mut input = Cow::from(&slice[..]);
+ match abs_all(&mut input) {
+ // TODO
+ }
+ }
+
+ #[test]
+ fn owned_no_mutation() -> Result<(), &'static str> {
+ // We can also pass `slice` without `&` so Cow owns it directly. In this
+ // case no mutation occurs and thus also no clone, but the result is
+ // still owned because it was never borrowed or mutated.
+ let slice = vec![0, 1, 2];
+ let mut input = Cow::from(slice);
+ match abs_all(&mut input) {
+ // TODO
+ }
+ }
+
+ #[test]
+ fn owned_mutation() -> Result<(), &'static str> {
+ // Of course this is also the case if a mutation does occur. In this
+ // case the call to `to_mut()` returns a reference to the same data as
+ // before.
+ let slice = vec![-1, 0, 1];
+ let mut input = Cow::from(slice);
+ match abs_all(&mut input) {
+ // TODO
+ }
+ }
+}
diff --git a/exercises/smart_pointers/rc1.rs b/exercises/smart_pointers/rc1.rs
new file mode 100644
index 00000000..ad3f1ce2
--- /dev/null
+++ b/exercises/smart_pointers/rc1.rs
@@ -0,0 +1,104 @@
+// rc1.rs
+//
+// In this exercise, we want to express the concept of multiple owners via the
+// Rc type. This is a model of our solar system - there is a Sun type and
+// multiple Planets. The Planets take ownership of the sun, indicating that they
+// revolve around the sun.
+//
+// Make this code compile by using the proper Rc primitives to express that the
+// sun has multiple owners.
+//
+// Execute `rustlings hint rc1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+use std::rc::Rc;
+
+#[derive(Debug)]
+struct Sun {}
+
+#[derive(Debug)]
+enum Planet {
+ Mercury(Rc),
+ Venus(Rc),
+ Earth(Rc),
+ Mars(Rc),
+ Jupiter(Rc),
+ Saturn(Rc),
+ Uranus(Rc),
+ Neptune(Rc),
+}
+
+impl Planet {
+ fn details(&self) {
+ println!("Hi from {:?}!", self)
+ }
+}
+
+fn main() {
+ let sun = Rc::new(Sun {});
+ println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference
+
+ let mercury = Planet::Mercury(Rc::clone(&sun));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 2 references
+ mercury.details();
+
+ let venus = Planet::Venus(Rc::clone(&sun));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 3 references
+ venus.details();
+
+ let earth = Planet::Earth(Rc::clone(&sun));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 4 references
+ earth.details();
+
+ let mars = Planet::Mars(Rc::clone(&sun));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 5 references
+ mars.details();
+
+ let jupiter = Planet::Jupiter(Rc::clone(&sun));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 6 references
+ jupiter.details();
+
+ // TODO
+ let saturn = Planet::Saturn(Rc::new(Sun {}));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
+ saturn.details();
+
+ // TODO
+ let uranus = Planet::Uranus(Rc::new(Sun {}));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
+ uranus.details();
+
+ // TODO
+ let neptune = Planet::Neptune(Rc::new(Sun {}));
+ println!("reference count = {}", Rc::strong_count(&sun)); // 9 references
+ neptune.details();
+
+ assert_eq!(Rc::strong_count(&sun), 9);
+
+ drop(neptune);
+ println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
+
+ drop(uranus);
+ println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
+
+ drop(saturn);
+ println!("reference count = {}", Rc::strong_count(&sun)); // 6 references
+
+ drop(jupiter);
+ println!("reference count = {}", Rc::strong_count(&sun)); // 5 references
+
+ drop(mars);
+ println!("reference count = {}", Rc::strong_count(&sun)); // 4 references
+
+ // TODO
+ println!("reference count = {}", Rc::strong_count(&sun)); // 3 references
+
+ // TODO
+ println!("reference count = {}", Rc::strong_count(&sun)); // 2 references
+
+ // TODO
+ println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference
+
+ assert_eq!(Rc::strong_count(&sun), 1);
+}
diff --git a/exercises/standard_library_types/README.md b/exercises/standard_library_types/README.md
deleted file mode 100644
index 36b30c1f..00000000
--- a/exercises/standard_library_types/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-For the Box exercise check out the chapter [Using Box to Point to Data on the Heap](https://doc.rust-lang.org/book/ch15-01-box.html).
-
-For the Arc exercise check out the chapter [Shared-State Concurrency](https://doc.rust-lang.org/book/ch16-03-shared-state.html) of the Rust Book.
-
-For the Iterator exercise check out the chapters [Iterator](https://doc.rust-lang.org/book/ch13-02-iterators.html) of the Rust Book and the [Iterator documentation](https://doc.rust-lang.org/stable/std/iter/).
-Do not adjust your monitors-- iterators1.rs is indeed missing. Iterators is a challenging topic, so we're leaving space for a simpler exercise!
-
diff --git a/exercises/standard_library_types/box1.rs b/exercises/standard_library_types/box1.rs
deleted file mode 100644
index 2eaa0bb4..00000000
--- a/exercises/standard_library_types/box1.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-// box1.rs
-//
-// At compile time, Rust needs to know how much space a type takes up. This becomes problematic
-// for recursive types, where a value can have as part of itself another value of the same type.
-// To get around the issue, we can use a `Box` - a smart pointer used to store data on the heap,
-// which also allows us to wrap a recursive type.
-//
-// The recursive type we're implementing in this exercise is the `cons list` - a data structure
-// frequently found in functional programming languages. Each item in a cons list contains two
-// elements: the value of the current item and the next item. The last item is a value called `Nil`.
-//
-// Step 1: use a `Box` in the enum definition to make the code compile
-// Step 2: create both empty and non-empty cons lists by replacing `unimplemented!()`
-//
-// Note: the tests should not be changed
-//
-// Execute `rustlings hint box1` for hints :)
-
-#[derive(PartialEq, Debug)]
-pub enum List {
- Cons(i32, Box),
- Nil,
-}
-
-fn main() {
- println!("This is an empty cons list: {:?}", create_empty_list());
- println!("This is a non-empty cons list: {:?}", create_non_empty_list());
-}
-
-pub fn create_empty_list() -> List {
- List::Nil
-}
-
-pub fn create_non_empty_list() -> List {
- List::Cons(1, Box::new(List::Nil))
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
-
- #[test]
- fn test_create_empty_list() {
- assert_eq!(List::Nil, create_empty_list())
- }
-
- #[test]
- fn test_create_non_empty_list() {
- assert_ne!(create_empty_list(), create_non_empty_list())
- }
-}
diff --git a/exercises/strings/README.md b/exercises/strings/README.md
index 38d24c84..fa2104cc 100644
--- a/exercises/strings/README.md
+++ b/exercises/strings/README.md
@@ -1,9 +1,9 @@
-### Strings
+# Strings
Rust has two string types, a string slice (`&str`) and an owned string (`String`).
We're not going to dictate when you should use which one, but we'll show you how
to identify and create them, as well as use them.
-#### Book Sections
+## Further information
- [Strings](https://doc.rust-lang.org/book/ch08-02-strings.html)
diff --git a/exercises/strings/strings1.rs b/exercises/strings/strings1.rs
index e43c88a4..c3212914 100644
--- a/exercises/strings/strings1.rs
+++ b/exercises/strings/strings1.rs
@@ -1,6 +1,9 @@
// strings1.rs
+//
// Make me compile without changing the function signature!
-// Execute `rustlings hint strings1` for hints ;)
+//
+// Execute `rustlings hint strings1` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let answer = current_favorite_color();
diff --git a/exercises/strings/strings2.rs b/exercises/strings/strings2.rs
index a048f882..ca16ea3d 100644
--- a/exercises/strings/strings2.rs
+++ b/exercises/strings/strings2.rs
@@ -1,6 +1,9 @@
// strings2.rs
+//
// Make me compile without changing the function signature!
-// Execute `rustlings hint strings2` for hints :)
+//
+// Execute `rustlings hint strings2` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let word = String::from("green"); // Try not changing this line :)
diff --git a/exercises/strings/strings3.rs b/exercises/strings/strings3.rs
new file mode 100644
index 00000000..b29f9325
--- /dev/null
+++ b/exercises/strings/strings3.rs
@@ -0,0 +1,45 @@
+// strings3.rs
+//
+// Execute `rustlings hint strings3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+fn trim_me(input: &str) -> String {
+ // TODO: Remove whitespace from both ends of a string!
+ ???
+}
+
+fn compose_me(input: &str) -> String {
+ // TODO: Add " world!" to the string! There's multiple ways to do this!
+ ???
+}
+
+fn replace_me(input: &str) -> String {
+ // TODO: Replace "cars" in the string with "balloons"!
+ ???
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn trim_a_string() {
+ assert_eq!(trim_me("Hello! "), "Hello!");
+ assert_eq!(trim_me(" What's up!"), "What's up!");
+ assert_eq!(trim_me(" Hola! "), "Hola!");
+ }
+
+ #[test]
+ fn compose_a_string() {
+ assert_eq!(compose_me("Hello"), "Hello world!");
+ assert_eq!(compose_me("Goodbye"), "Goodbye world!");
+ }
+
+ #[test]
+ fn replace_a_string() {
+ assert_eq!(replace_me("I think cars are cool"), "I think balloons are cool");
+ assert_eq!(replace_me("I love to look at cars"), "I love to look at balloons");
+ }
+}
diff --git a/exercises/strings/strings4.rs b/exercises/strings/strings4.rs
new file mode 100644
index 00000000..e8c54acc
--- /dev/null
+++ b/exercises/strings/strings4.rs
@@ -0,0 +1,30 @@
+// strings4.rs
+//
+// Ok, here are a bunch of values-- some are `String`s, some are `&str`s. Your
+// task is to call one of these two functions on each value depending on what
+// you think each value is. That is, add either `string_slice` or `string`
+// before the parentheses on each line. If you're right, it will compile!
+//
+// No hints this time!
+
+// I AM NOT DONE
+
+fn string_slice(arg: &str) {
+ println!("{}", arg);
+}
+fn string(arg: String) {
+ println!("{}", arg);
+}
+
+fn main() {
+ ???("blue");
+ ???("red".to_string());
+ ???(String::from("hi"));
+ ???("rust is fun!".to_owned());
+ ???("nice weather".into());
+ ???(format!("Interpolation {}", "Station"));
+ ???(&String::from("abc")[0..1]);
+ ???(" hello there ".trim());
+ ???("Happy Monday!".to_string().replace("Mon", "Tues"));
+ ???("mY sHiFt KeY iS sTiCkY".to_lowercase());
+}
diff --git a/exercises/structs/README.md b/exercises/structs/README.md
index afbc72c8..3fc1fdc9 100644
--- a/exercises/structs/README.md
+++ b/exercises/structs/README.md
@@ -1,7 +1,8 @@
-### Structs
+# Structs
-Rust has three struct types: a classic c struct, a tuple struct, and a unit struct.
+Rust has three struct types: a classic C struct, a tuple struct, and a unit struct.
-#### Book Sections
+## Further information
-- [Structures](https://doc.rust-lang.org/rust-by-example/custom_types/structs.html)
+- [Structures](https://doc.rust-lang.org/book/ch05-01-defining-structs.html)
+- [Method Syntax](https://doc.rust-lang.org/book/ch05-03-method-syntax.html)
diff --git a/exercises/structs/structs1.rs b/exercises/structs/structs1.rs
index cd5d32a4..e1801694 100644
--- a/exercises/structs/structs1.rs
+++ b/exercises/structs/structs1.rs
@@ -1,5 +1,9 @@
// structs1.rs
+//
// Address all the TODOs to make the tests pass!
+//
+// Execute `rustlings hint structs1` or use the `hint` watch subcommand for a
+// hint.
struct ColorClassicStruct {
// TODO: Something goes here
@@ -10,7 +14,7 @@ struct ColorClassicStruct {
struct ColorTupleStruct(String, String);
#[derive(Debug)]
-struct UnitStruct;
+struct UnitLikeStruct;
#[cfg(test)]
mod tests {
@@ -24,8 +28,9 @@ mod tests {
hex: String::from("#00FF00"),
};
- assert_eq!(green.name, "green");
- assert_eq!(green.hex, "#00FF00");
+ assert_eq!(green.red, 0);
+ assert_eq!(green.green, 255);
+ assert_eq!(green.blue, 0);
}
#[test]
@@ -33,16 +38,23 @@ mod tests {
// TODO: Instantiate a tuple struct!
let green = ColorTupleStruct(String::from("green"), String::from("#00FF00"));
- assert_eq!(green.0, "green");
- assert_eq!(green.1, "#00FF00");
+ assert_eq!(green.0, 0);
+ assert_eq!(green.1, 255);
+ assert_eq!(green.2, 0);
}
#[test]
fn unit_structs() {
+<<<<<<< HEAD
// TODO: Instantiate a unit struct!
let unit_struct = UnitStruct;
let message = format!("{:?}s are fun!", unit_struct);
+=======
+ // TODO: Instantiate a unit-like struct!
+ // let unit_like_struct =
+ let message = format!("{:?}s are fun!", unit_like_struct);
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
- assert_eq!(message, "UnitStructs are fun!");
+ assert_eq!(message, "UnitLikeStructs are fun!");
}
}
diff --git a/exercises/structs/structs2.rs b/exercises/structs/structs2.rs
index 80027625..7e3dd7c7 100644
--- a/exercises/structs/structs2.rs
+++ b/exercises/structs/structs2.rs
@@ -1,5 +1,9 @@
// structs2.rs
+//
// Address all the TODOs to make the tests pass!
+//
+// Execute `rustlings hint structs2` or use the `hint` watch subcommand for a
+// hint.
#[derive(Debug)]
struct Order {
diff --git a/exercises/structs/structs3.rs b/exercises/structs/structs3.rs
index 84b1638d..7bdd1717 100644
--- a/exercises/structs/structs3.rs
+++ b/exercises/structs/structs3.rs
@@ -1,7 +1,11 @@
// structs3.rs
-// Structs contain more than simply some data, they can also have logic, in this
-// exercise we have defined the Package struct and we want to test some logic attached to it,
-// make the code compile and the tests pass! If you have issues execute `rustlings hint structs3`
+//
+// Structs contain data, but can also have logic. In this exercise we have
+// defined the Package struct and we want to test some logic attached to it.
+// Make the code compile and the tests pass!
+//
+// Execute `rustlings hint structs3` or use the `hint` watch subcommand for a
+// hint.
#[derive(Debug)]
struct Package {
@@ -13,10 +17,18 @@ struct Package {
impl Package {
fn new(sender_country: String, recipient_country: String, weight_in_grams: i32) -> Package {
if weight_in_grams <= 0 {
+<<<<<<< HEAD
// Something goes here...
panic!("Package is lighter then air!")
+=======
+ panic!("Can not ship a weightless package.")
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
} else {
- return Package {sender_country, recipient_country, weight_in_grams};
+ Package {
+ sender_country,
+ recipient_country,
+ weight_in_grams,
+ }
}
}
@@ -25,9 +37,14 @@ impl Package {
self.recipient_country != self.sender_country
}
+<<<<<<< HEAD
fn get_fees(&self, cents_per_kg: i32) -> i32 {
// Something goes here... (beware of grams to kg conversion)
(self.weight_in_grams * cents_per_kg) / 100
+=======
+ fn get_fees(&self, cents_per_gram: i32) -> ??? {
+ // Something goes here...
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
}
@@ -48,21 +65,37 @@ mod tests {
fn create_international_package() {
let sender_country = String::from("Spain");
let recipient_country = String::from("Russia");
-
+
let package = Package::new(sender_country, recipient_country, 1200);
assert!(package.is_international());
}
+ #[test]
+ fn create_local_package() {
+ let sender_country = String::from("Canada");
+ let recipient_country = sender_country.clone();
+
+ let package = Package::new(sender_country, recipient_country, 1200);
+
+ assert!(!package.is_international());
+ }
+
#[test]
fn calculate_transport_fees() {
let sender_country = String::from("Spain");
let recipient_country = String::from("Spain");
+<<<<<<< HEAD
let cents_per_kg = 300;
+=======
+ let cents_per_gram = 3;
+
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
let package = Package::new(sender_country, recipient_country, 1500);
-
- assert_eq!(package.get_fees(cents_per_kg), 4500);
+
+ assert_eq!(package.get_fees(cents_per_gram), 4500);
+ assert_eq!(package.get_fees(cents_per_gram * 2), 9000);
}
}
diff --git a/exercises/tests/README.md b/exercises/tests/README.md
index dbb14a83..27c6818d 100644
--- a/exercises/tests/README.md
+++ b/exercises/tests/README.md
@@ -1,7 +1,7 @@
-### Tests
+# Tests
Going out of order from the book to cover tests -- many of the following exercises will ask you to make tests pass!
-#### Book Sections
+## Further information
- [Writing Tests](https://doc.rust-lang.org/book/ch11-01-writing-tests.html)
diff --git a/exercises/tests/tests1.rs b/exercises/tests/tests1.rs
index 005731fd..eab3ba7a 100644
--- a/exercises/tests/tests1.rs
+++ b/exercises/tests/tests1.rs
@@ -1,10 +1,14 @@
// tests1.rs
-// Tests are important to ensure that your code does what you think it should do.
-// Tests can be run on this file with the following command:
-// rustlings run tests1
-
-// This test has a problem with it -- make the test compile! Make the test
-// pass! Make the test fail! Execute `rustlings hint tests1` for hints :)
+//
+// Tests are important to ensure that your code does what you think it should
+// do. Tests can be run on this file with the following command: rustlings run
+// tests1
+//
+// This test has a problem with it -- make the test compile! Make the test pass!
+// Make the test fail!
+//
+// Execute `rustlings hint tests1` or use the `hint` watch subcommand for a
+// hint.
#[cfg(test)]
mod tests {
diff --git a/exercises/tests/tests2.rs b/exercises/tests/tests2.rs
index a167f18a..6340579a 100644
--- a/exercises/tests/tests2.rs
+++ b/exercises/tests/tests2.rs
@@ -1,6 +1,10 @@
// tests2.rs
-// This test has a problem with it -- make the test compile! Make the test
-// pass! Make the test fail! Execute `rustlings hint tests2` for hints :)
+//
+// This test has a problem with it -- make the test compile! Make the test pass!
+// Make the test fail!
+//
+// Execute `rustlings hint tests2` or use the `hint` watch subcommand for a
+// hint.
#[cfg(test)]
mod tests {
diff --git a/exercises/tests/tests3.rs b/exercises/tests/tests3.rs
index 785ab7fb..ef5120aa 100644
--- a/exercises/tests/tests3.rs
+++ b/exercises/tests/tests3.rs
@@ -1,8 +1,11 @@
// tests3.rs
+//
// This test isn't testing our function -- make it do that in such a way that
-// the test passes. Then write a second test that tests whether we get the result
-// we expect to get when we call `is_even(5)`.
-// Execute `rustlings hint tests3` for hints :)
+// the test passes. Then write a second test that tests whether we get the
+// result we expect to get when we call `is_even(5)`.
+//
+// Execute `rustlings hint tests3` or use the `hint` watch subcommand for a
+// hint.
pub fn is_even(num: i32) -> bool {
num % 2 == 0
@@ -16,4 +19,9 @@ mod tests {
fn is_true_when_even() {
assert!(is_even(224));
}
+
+ #[test]
+ fn is_false_when_odd() {
+ assert!();
+ }
}
diff --git a/exercises/tests/tests4.rs b/exercises/tests/tests4.rs
new file mode 100644
index 00000000..935d0db1
--- /dev/null
+++ b/exercises/tests/tests4.rs
@@ -0,0 +1,48 @@
+// tests4.rs
+//
+// Make sure that we're testing for the correct conditions!
+//
+// Execute `rustlings hint tests4` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+struct Rectangle {
+ width: i32,
+ height: i32
+}
+
+impl Rectangle {
+ // Only change the test functions themselves
+ pub fn new(width: i32, height: i32) -> Self {
+ if width <= 0 || height <= 0 {
+ panic!("Rectangle width and height cannot be negative!")
+ }
+ Rectangle {width, height}
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn correct_width_and_height() {
+ // This test should check if the rectangle is the size that we pass into its constructor
+ let rect = Rectangle::new(10, 20);
+ assert_eq!(???, 10); // check width
+ assert_eq!(???, 20); // check height
+ }
+
+ #[test]
+ fn negative_width() {
+ // This test should check if program panics when we try to create rectangle with negative width
+ let _rect = Rectangle::new(-10, 10);
+ }
+
+ #[test]
+ fn negative_height() {
+ // This test should check if program panics when we try to create rectangle with negative height
+ let _rect = Rectangle::new(10, -10);
+ }
+}
diff --git a/exercises/threads/README.md b/exercises/threads/README.md
index 2024292f..d0866947 100644
--- a/exercises/threads/README.md
+++ b/exercises/threads/README.md
@@ -1 +1,9 @@
-For this exercise check out the [Dining Philosophers example](https://doc.rust-lang.org/1.4.0/book/dining-philosophers.html) and the chapter [Concurrency](https://doc.rust-lang.org/book/ch16-01-threads.html) of the Rust Book.
\ No newline at end of file
+# Threads
+
+In most current operating systems, an executed program’s code is run in a process, and the operating system manages multiple processes at once.
+Within your program, you can also have independent parts that run simultaneously. The features that run these independent parts are called threads.
+
+## Further information
+
+- [Dining Philosophers example](https://doc.rust-lang.org/1.4.0/book/dining-philosophers.html)
+- [Using Threads to Run Code Simultaneously](https://doc.rust-lang.org/book/ch16-01-threads.html)
diff --git a/exercises/threads/threads1.rs b/exercises/threads/threads1.rs
index 2952930f..20f36cc4 100644
--- a/exercises/threads/threads1.rs
+++ b/exercises/threads/threads1.rs
@@ -1,19 +1,24 @@
// threads1.rs
-// Make this compile! Execute `rustlings hint threads1` for hints :)
-// The idea is the thread spawned on line 21 is completing jobs while the main thread is
-// monitoring progress until 10 jobs are completed. If you see 6 lines
-// of "waiting..." and the program ends without timing out when running,
-// you've got it :)
+//
+// This program spawns multiple threads that each run for at least 250ms, and
+// each thread returns how much time they took to complete. The program should
+// wait until all the spawned threads have finished and should collect their
+// return values into a vector.
+//
+// Execute `rustlings hint threads1` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
use std::sync::{Arc, Mutex};
-use std::thread;
-use std::time::Duration;
+=======
+// I AM NOT DONE
-struct JobStatus {
- jobs_completed: u32,
-}
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
+use std::thread;
+use std::time::{Duration, Instant};
fn main() {
+<<<<<<< HEAD
// Introduce Mutex
let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
let status_shared = status.clone();
@@ -29,5 +34,29 @@ fn main() {
while status.lock().unwrap().jobs_completed < 10 {
println!("waiting... ");
thread::sleep(Duration::from_millis(500));
+=======
+ let mut handles = vec![];
+ for i in 0..10 {
+ handles.push(thread::spawn(move || {
+ let start = Instant::now();
+ thread::sleep(Duration::from_millis(250));
+ println!("thread {} is complete", i);
+ start.elapsed().as_millis()
+ }));
+ }
+
+ let mut results: Vec = vec![];
+ for handle in handles {
+ // TODO: a struct is returned from thread::spawn, can you use it?
+ }
+
+ if results.len() != 10 {
+ panic!("Oh no! All the spawned threads did not finish!");
+ }
+
+ println!();
+ for (i, result) in results.into_iter().enumerate() {
+ println!("thread {} took {}ms", i, result);
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
}
diff --git a/exercises/threads/threads2.rs b/exercises/threads/threads2.rs
new file mode 100644
index 00000000..62dad80d
--- /dev/null
+++ b/exercises/threads/threads2.rs
@@ -0,0 +1,39 @@
+// threads2.rs
+//
+// Building on the last exercise, we want all of the threads to complete their
+// work but this time the spawned threads need to be in charge of updating a
+// shared value: JobStatus.jobs_completed
+//
+// Execute `rustlings hint threads2` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+struct JobStatus {
+ jobs_completed: u32,
+}
+
+fn main() {
+ let status = Arc::new(JobStatus { jobs_completed: 0 });
+ let mut handles = vec![];
+ for _ in 0..10 {
+ let status_shared = Arc::clone(&status);
+ let handle = thread::spawn(move || {
+ thread::sleep(Duration::from_millis(250));
+ // TODO: You must take an action before you update a shared value
+ status_shared.jobs_completed += 1;
+ });
+ handles.push(handle);
+ }
+ for handle in handles {
+ handle.join().unwrap();
+ // TODO: Print the value of the JobStatus.jobs_completed. Did you notice
+ // anything interesting in the output? Do you have to 'join' on all the
+ // handles?
+ println!("jobs completed {}", ???);
+ }
+}
diff --git a/exercises/threads/threads3.rs b/exercises/threads/threads3.rs
new file mode 100644
index 00000000..db7d41ba
--- /dev/null
+++ b/exercises/threads/threads3.rs
@@ -0,0 +1,66 @@
+// threads3.rs
+//
+// Execute `rustlings hint threads3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+use std::sync::mpsc;
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+struct Queue {
+ length: u32,
+ first_half: Vec,
+ second_half: Vec,
+}
+
+impl Queue {
+ fn new() -> Self {
+ Queue {
+ length: 10,
+ first_half: vec![1, 2, 3, 4, 5],
+ second_half: vec![6, 7, 8, 9, 10],
+ }
+ }
+}
+
+fn send_tx(q: Queue, tx: mpsc::Sender) -> () {
+ let qc = Arc::new(q);
+ let qc1 = Arc::clone(&qc);
+ let qc2 = Arc::clone(&qc);
+
+ thread::spawn(move || {
+ for val in &qc1.first_half {
+ println!("sending {:?}", val);
+ tx.send(*val).unwrap();
+ thread::sleep(Duration::from_secs(1));
+ }
+ });
+
+ thread::spawn(move || {
+ for val in &qc2.second_half {
+ println!("sending {:?}", val);
+ tx.send(*val).unwrap();
+ thread::sleep(Duration::from_secs(1));
+ }
+ });
+}
+
+fn main() {
+ let (tx, rx) = mpsc::channel();
+ let queue = Queue::new();
+ let queue_length = queue.length;
+
+ send_tx(queue, tx);
+
+ let mut total_received: u32 = 0;
+ for received in rx {
+ println!("Got: {}", received);
+ total_received += 1;
+ }
+
+ println!("total numbers received: {}", total_received);
+ assert_eq!(total_received, queue_length)
+}
diff --git a/exercises/traits/README.md b/exercises/traits/README.md
index 1ce46fe0..ac87c64e 100644
--- a/exercises/traits/README.md
+++ b/exercises/traits/README.md
@@ -1,6 +1,6 @@
-### Traits
+# Traits
-A trait is a collection of methods.
+A trait is a collection of methods.
Data types can implement traits. To do so, the methods making up the trait are defined for the data type. For example, the `String` data type implements the `From<&str>` trait. This allows a user to write `String::from("hello")`.
@@ -8,13 +8,12 @@ In this way, traits are somewhat similar to Java interfaces and C++ abstract cla
Some additional common Rust traits include:
-+ `Clone` (the `clone` method),
-+ `Display` (which allows formatted display via `{}`), and
-+ `Debug` (which allows formatted display via `{:?}`).
+- `Clone` (the `clone` method)
+- `Display` (which allows formatted display via `{}`)
+- `Debug` (which allows formatted display via `{:?}`)
Because traits indicate shared behavior between data types, they are useful when writing generics.
+## Further information
-#### Book Sections
-
-- [Traits](https://doc.rust-lang.org/book/ch10-02-traits.html)
\ No newline at end of file
+- [Traits](https://doc.rust-lang.org/book/ch10-02-traits.html)
diff --git a/exercises/traits/traits1.rs b/exercises/traits/traits1.rs
index 4cef7cd2..6e00cce9 100644
--- a/exercises/traits/traits1.rs
+++ b/exercises/traits/traits1.rs
@@ -1,21 +1,29 @@
// traits1.rs
-// Time to implement some traits!
-//
-// Your task is to implement the trait
-// `AppendBar' for the type `String'.
-//
-// The trait AppendBar has only one function,
-// which appends "Bar" to any object
-// implementing this trait.
+//
+// Time to implement some traits! Your task is to implement the trait
+// `AppendBar` for the type `String`. The trait AppendBar has only one function,
+// which appends "Bar" to any object implementing this trait.
+//
+// Execute `rustlings hint traits1` or use the `hint` watch subcommand for a
+// hint.
+<<<<<<< HEAD
+=======
+// I AM NOT DONE
+
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
trait AppendBar {
fn append_bar(self) -> Self;
}
impl AppendBar for String {
+<<<<<<< HEAD
fn append_bar(self) -> Self {
self + "Bar"
}
+=======
+ // TODO: Implement `AppendBar` for type `String`.
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
fn main() {
@@ -29,16 +37,15 @@ mod tests {
use super::*;
#[test]
- fn is_FooBar() {
+ fn is_foo_bar() {
assert_eq!(String::from("Foo").append_bar(), String::from("FooBar"));
}
#[test]
- fn is_BarBar() {
+ fn is_bar_bar() {
assert_eq!(
String::from("").append_bar().append_bar(),
String::from("BarBar")
);
}
-
-}
\ No newline at end of file
+}
diff --git a/exercises/traits/traits2.rs b/exercises/traits/traits2.rs
index 34b0ce29..f9e19186 100644
--- a/exercises/traits/traits2.rs
+++ b/exercises/traits/traits2.rs
@@ -1,25 +1,27 @@
// traits2.rs
-//
-// Your task is to implement the trait
-// `AppendBar' for a vector of strings.
-//
-// To implement this trait, consider for
-// a moment what it means to 'append "Bar"'
+//
+// Your task is to implement the trait `AppendBar` for a vector of strings. To
+// implement this trait, consider for a moment what it means to 'append "Bar"'
// to a vector of strings.
-//
-// No boiler plate code this time,
-// you can do this!
+//
+// No boiler plate code this time, you can do this!
+//
+// Execute `rustlings hint traits2` or use the `hint` watch subcommand for a hint.
trait AppendBar {
fn append_bar(self) -> Self;
}
+<<<<<<< HEAD
impl AppendBar for Vec {
fn append_bar(mut self) -> Self {
self.push(String::from("Bar"));
self
}
}
+=======
+// TODO: Implement trait `AppendBar` for a vector of strings.
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
#[cfg(test)]
mod tests {
@@ -31,5 +33,4 @@ mod tests {
assert_eq!(foo.pop().unwrap(), String::from("Bar"));
assert_eq!(foo.pop().unwrap(), String::from("Foo"));
}
-
}
diff --git a/exercises/traits/traits3.rs b/exercises/traits/traits3.rs
new file mode 100644
index 00000000..4e2b06b0
--- /dev/null
+++ b/exercises/traits/traits3.rs
@@ -0,0 +1,42 @@
+// traits3.rs
+//
+// Your task is to implement the Licensed trait for both structures and have
+// them return the same information without writing the same function twice.
+//
+// Consider what you can add to the Licensed trait.
+//
+// Execute `rustlings hint traits3` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+pub trait Licensed {
+ fn licensing_info(&self) -> String;
+}
+
+struct SomeSoftware {
+ version_number: i32,
+}
+
+struct OtherSoftware {
+ version_number: String,
+}
+
+impl Licensed for SomeSoftware {} // Don't edit this line
+impl Licensed for OtherSoftware {} // Don't edit this line
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn is_licensing_info_the_same() {
+ let licensing_info = String::from("Some information");
+ let some_software = SomeSoftware { version_number: 1 };
+ let other_software = OtherSoftware {
+ version_number: "v2.0.0".to_string(),
+ };
+ assert_eq!(some_software.licensing_info(), licensing_info);
+ assert_eq!(other_software.licensing_info(), licensing_info);
+ }
+}
diff --git a/exercises/traits/traits4.rs b/exercises/traits/traits4.rs
new file mode 100644
index 00000000..4bda3e57
--- /dev/null
+++ b/exercises/traits/traits4.rs
@@ -0,0 +1,49 @@
+// traits4.rs
+//
+// Your task is to replace the '??' sections so the code compiles.
+//
+// Don't change any line other than the marked one.
+//
+// Execute `rustlings hint traits4` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+pub trait Licensed {
+ fn licensing_info(&self) -> String {
+ "some information".to_string()
+ }
+}
+
+struct SomeSoftware {}
+
+struct OtherSoftware {}
+
+impl Licensed for SomeSoftware {}
+impl Licensed for OtherSoftware {}
+
+// YOU MAY ONLY CHANGE THE NEXT LINE
+fn compare_license_types(software: ??, software_two: ??) -> bool {
+ software.licensing_info() == software_two.licensing_info()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn compare_license_information() {
+ let some_software = SomeSoftware {};
+ let other_software = OtherSoftware {};
+
+ assert!(compare_license_types(some_software, other_software));
+ }
+
+ #[test]
+ fn compare_license_information_backwards() {
+ let some_software = SomeSoftware {};
+ let other_software = OtherSoftware {};
+
+ assert!(compare_license_types(other_software, some_software));
+ }
+}
diff --git a/exercises/traits/traits5.rs b/exercises/traits/traits5.rs
new file mode 100644
index 00000000..df183805
--- /dev/null
+++ b/exercises/traits/traits5.rs
@@ -0,0 +1,40 @@
+// traits5.rs
+//
+// Your task is to replace the '??' sections so the code compiles.
+//
+// Don't change any line other than the marked one.
+//
+// Execute `rustlings hint traits5` or use the `hint` watch subcommand for a
+// hint.
+
+// I AM NOT DONE
+
+pub trait SomeTrait {
+ fn some_function(&self) -> bool {
+ true
+ }
+}
+
+pub trait OtherTrait {
+ fn other_function(&self) -> bool {
+ true
+ }
+}
+
+struct SomeStruct {}
+struct OtherStruct {}
+
+impl SomeTrait for SomeStruct {}
+impl OtherTrait for SomeStruct {}
+impl SomeTrait for OtherStruct {}
+impl OtherTrait for OtherStruct {}
+
+// YOU MAY ONLY CHANGE THE NEXT LINE
+fn some_func(item: ??) -> bool {
+ item.some_function() && item.other_function()
+}
+
+fn main() {
+ some_func(SomeStruct {});
+ some_func(OtherStruct {});
+}
diff --git a/exercises/variables/README.md b/exercises/variables/README.md
index 1e2eb596..7964ff29 100644
--- a/exercises/variables/README.md
+++ b/exercises/variables/README.md
@@ -1,7 +1,9 @@
-### Variables
+# Variables
-Here you'll learn about simple variables.
+In Rust, variables are immutable by default.
+When a variable is immutable, once a value is bound to a name, you can’t change that value.
+You can make them mutable by adding `mut` in front of the variable name.
-#### Book Sections
+## Further information
- [Variables and Mutability](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html)
diff --git a/exercises/variables/variables1.rs b/exercises/variables/variables1.rs
index db85e7e4..98a0cf22 100644
--- a/exercises/variables/variables1.rs
+++ b/exercises/variables/variables1.rs
@@ -1,10 +1,9 @@
// variables1.rs
-// Make me compile! Execute the command `rustlings hint variables1` if you want a hint :)
-
-// About this `I AM NOT DONE` thing:
-// We sometimes encourage you to keep trying things on a given exercise,
-// even after you already figured it out. If you got everything working and
-// feel ready for the next exercise, remove the `I AM NOT DONE` comment below.
+//
+// Make me compile!
+//
+// Execute `rustlings hint variables1` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let x = 5;
diff --git a/exercises/variables/variables2.rs b/exercises/variables/variables2.rs
index 2119027a..dd85806e 100644
--- a/exercises/variables/variables2.rs
+++ b/exercises/variables/variables2.rs
@@ -1,11 +1,13 @@
// variables2.rs
-// Make me compile! Execute the command `rustlings hint variables2` if you want a hint :)
+//
+// Execute `rustlings hint variables2` or use the `hint` watch subcommand for a
+// hint.
fn main() {
let x: i32 = 10;
if x == 10 {
- println!("Ten!");
+ println!("x is ten!");
} else {
- println!("Not ten!");
+ println!("x is not ten!");
}
}
diff --git a/exercises/variables/variables3.rs b/exercises/variables/variables3.rs
index 7d84709d..aecbbc5f 100644
--- a/exercises/variables/variables3.rs
+++ b/exercises/variables/variables3.rs
@@ -1,9 +1,15 @@
// variables3.rs
-// Make me compile! Execute the command `rustlings hint variables3` if you want a hint :)
+//
+// Execute `rustlings hint variables3` or use the `hint` watch subcommand for a
+// hint.
fn main() {
+<<<<<<< HEAD
let mut x = 3;
println!("Number {}", x);
x = 5; // don't change this line
+=======
+ let x: i32;
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
println!("Number {}", x);
}
diff --git a/exercises/variables/variables4.rs b/exercises/variables/variables4.rs
index 33725df0..7da4a366 100644
--- a/exercises/variables/variables4.rs
+++ b/exercises/variables/variables4.rs
@@ -1,7 +1,15 @@
// variables4.rs
-// Make me compile! Execute the command `rustlings hint variables4` if you want a hint :)
+//
+// Execute `rustlings hint variables4` or use the `hint` watch subcommand for a
+// hint.
fn main() {
+<<<<<<< HEAD
let x: i32 = 256 * 256 * 256;
+=======
+ let x = 3;
+ println!("Number {}", x);
+ x = 5; // don't change this line
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
println!("Number {}", x);
}
diff --git a/exercises/variables/variables5.rs b/exercises/variables/variables5.rs
index b87d5019..df745076 100644
--- a/exercises/variables/variables5.rs
+++ b/exercises/variables/variables5.rs
@@ -1,9 +1,18 @@
// variables5.rs
-// Make me compile! Execute the command `rustlings hint variables5` if you want a hint :)
+//
+// Execute `rustlings hint variables5` or use the `hint` watch subcommand for a
+// hint.
fn main() {
+<<<<<<< HEAD
let number = "3"; // don't change this line
println!("Number {}", number);
let number = 3;
println!("Number {}", number);
+=======
+ let number = "T-H-R-E-E"; // don't change this line
+ println!("Spell a Number : {}", number);
+ number = 3; // don't rename this variable
+ println!("Number plus two is : {}", number + 2);
+>>>>>>> 11d8aea96f2c744d970ed1ffb38785cf5b511e5e
}
diff --git a/exercises/variables/variables6.rs b/exercises/variables/variables6.rs
index b4bed965..0b69e92c 100644
--- a/exercises/variables/variables6.rs
+++ b/exercises/variables/variables6.rs
@@ -1,5 +1,7 @@
// variables6.rs
-// Make me compile! Execute the command `rustlings hint variables6` if you want a hint :)
+//
+// Execute `rustlings hint variables6` or use the `hint` watch subcommand for a
+// hint.
const NUMBER: u8 = 3;
fn main() {
diff --git a/exercises/vecs/README.md b/exercises/vecs/README.md
new file mode 100644
index 00000000..8ff9b85f
--- /dev/null
+++ b/exercises/vecs/README.md
@@ -0,0 +1,17 @@
+# Vectors
+
+Vectors are one of the most-used Rust data structures. In other programming
+languages, they'd simply be called Arrays, but since Rust operates on a
+bit of a lower level, an array in Rust is stored on the stack (meaning it
+can't grow or shrink, and the size needs to be known at compile time),
+and a Vector is stored in the heap (where these restrictions do not apply).
+
+Vectors are a bit of a later chapter in the book, but we think that they're
+useful enough to talk about them a bit earlier. We shall be talking about
+the other useful data structure, hash maps, later.
+
+## Further information
+
+- [Storing Lists of Values with Vectors](https://doc.rust-lang.org/stable/book/ch08-01-vectors.html)
+- [`iter_mut`](https://doc.rust-lang.org/std/primitive.slice.html#method.iter_mut)
+- [`map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map)
diff --git a/exercises/vecs/vecs1.rs b/exercises/vecs/vecs1.rs
new file mode 100644
index 00000000..65b7a7f8
--- /dev/null
+++ b/exercises/vecs/vecs1.rs
@@ -0,0 +1,28 @@
+// vecs1.rs
+//
+// Your task is to create a `Vec` which holds the exact same elements as in the
+// array `a`.
+//
+// Make me compile and pass the test!
+//
+// Execute `rustlings hint vecs1` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn array_and_vec() -> ([i32; 4], Vec) {
+ let a = [10, 20, 30, 40]; // a plain array
+ let v = // TODO: declare your vector here with the macro for vectors
+
+ (a, v)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_array_and_vec_similarity() {
+ let (a, v) = array_and_vec();
+ assert_eq!(a, v[..]);
+ }
+}
diff --git a/exercises/vecs/vecs2.rs b/exercises/vecs/vecs2.rs
new file mode 100644
index 00000000..e92c970a
--- /dev/null
+++ b/exercises/vecs/vecs2.rs
@@ -0,0 +1,50 @@
+// vecs2.rs
+//
+// A Vec of even numbers is given. Your task is to complete the loop so that
+// each number in the Vec is multiplied by 2.
+//
+// Make me pass the test!
+//
+// Execute `rustlings hint vecs2` or use the `hint` watch subcommand for a hint.
+
+// I AM NOT DONE
+
+fn vec_loop(mut v: Vec) -> Vec {
+ for element in v.iter_mut() {
+ // TODO: Fill this up so that each element in the Vec `v` is
+ // multiplied by 2.
+ ???
+ }
+
+ // At this point, `v` should be equal to [4, 8, 12, 16, 20].
+ v
+}
+
+fn vec_map(v: &Vec) -> Vec {
+ v.iter().map(|element| {
+ // TODO: Do the same thing as above - but instead of mutating the
+ // Vec, you can just return the new number!
+ ???
+ }).collect()
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_vec_loop() {
+ let v: Vec = (1..).filter(|x| x % 2 == 0).take(5).collect();
+ let ans = vec_loop(v.clone());
+
+ assert_eq!(ans, v.iter().map(|x| x * 2).collect::>());
+ }
+
+ #[test]
+ fn test_vec_map() {
+ let v: Vec = (1..).filter(|x| x % 2 == 0).take(5).collect();
+ let ans = vec_map(&v);
+
+ assert_eq!(ans, v.iter().map(|x| x * 2).collect::>());
+ }
+}
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 00000000..ceb62c6d
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,60 @@
+{
+ "nodes": {
+ "flake-compat": {
+ "flake": false,
+ "locked": {
+ "lastModified": 1650374568,
+ "narHash": "sha256-Z+s0J8/r907g149rllvwhb4pKi8Wam5ij0st8PwAh+E=",
+ "owner": "edolstra",
+ "repo": "flake-compat",
+ "rev": "b4a34015c698c7793d592d66adbab377907a2be8",
+ "type": "github"
+ },
+ "original": {
+ "owner": "edolstra",
+ "repo": "flake-compat",
+ "type": "github"
+ }
+ },
+ "flake-utils": {
+ "locked": {
+ "lastModified": 1659877975,
+ "narHash": "sha256-zllb8aq3YO3h8B/U0/J1WBgAL8EX5yWf5pMj3G0NAmc=",
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "rev": "c0e246b9b83f637f4681389ecabcb2681b4f3af0",
+ "type": "github"
+ },
+ "original": {
+ "owner": "numtide",
+ "repo": "flake-utils",
+ "type": "github"
+ }
+ },
+ "nixpkgs": {
+ "locked": {
+ "lastModified": 1666629043,
+ "narHash": "sha256-Yoq6Ut2F3Ol73yO9hG93x6ts5c4F5BhKTbcF3DtBEAw=",
+ "owner": "nixos",
+ "repo": "nixpkgs",
+ "rev": "b39fd6e4edef83cb4a135ebef98751ce23becc33",
+ "type": "github"
+ },
+ "original": {
+ "owner": "nixos",
+ "ref": "nixos-unstable",
+ "repo": "nixpkgs",
+ "type": "github"
+ }
+ },
+ "root": {
+ "inputs": {
+ "flake-compat": "flake-compat",
+ "flake-utils": "flake-utils",
+ "nixpkgs": "nixpkgs"
+ }
+ }
+ },
+ "root": "root",
+ "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 00000000..5dbca5c2
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,64 @@
+{
+ description = "Small exercises to get you used to reading and writing Rust code";
+
+ inputs = {
+ flake-compat = {
+ url = "github:edolstra/flake-compat";
+ flake = false;
+ };
+ flake-utils.url = "github:numtide/flake-utils";
+ nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
+ };
+
+ outputs = { self, flake-utils, nixpkgs, ... }:
+ flake-utils.lib.eachDefaultSystem (system:
+ let
+ pkgs = nixpkgs.legacyPackages.${system};
+
+ cargoBuildInputs = with pkgs; lib.optionals stdenv.isDarwin [
+ darwin.apple_sdk.frameworks.CoreServices
+ ];
+
+ rustlings =
+ pkgs.rustPlatform.buildRustPackage {
+ name = "rustlings";
+ version = "5.5.1";
+
+ buildInputs = cargoBuildInputs;
+
+ src = with pkgs.lib; cleanSourceWith {
+ src = self;
+ # a function that returns a bool determining if the path should be included in the cleaned source
+ filter = path: type:
+ let
+ # filename
+ baseName = builtins.baseNameOf (toString path);
+ # path from root directory
+ path' = builtins.replaceStrings [ "${self}/" ] [ "" ] path;
+ # checks if path is in the directory
+ inDirectory = directory: hasPrefix directory path';
+ in
+ inDirectory "src" ||
+ inDirectory "tests" ||
+ hasPrefix "Cargo" baseName ||
+ baseName == "info.toml";
+ };
+
+ cargoLock.lockFile = ./Cargo.lock;
+ };
+ in
+ {
+ devShell = pkgs.mkShell {
+ RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
+
+ buildInputs = with pkgs; [
+ cargo
+ rustc
+ rust-analyzer
+ rustlings
+ rustfmt
+ clippy
+ ] ++ cargoBuildInputs;
+ };
+ });
+}
diff --git a/info.toml b/info.toml
index ee4ab2f6..e8a28cbc 100644
--- a/info.toml
+++ b/info.toml
@@ -1,3 +1,20 @@
+# INTRO
+
+[[exercises]]
+name = "intro1"
+path = "exercises/intro/intro1.rs"
+mode = "compile"
+hint = """
+Remove the I AM NOT DONE comment in the exercises/intro/intro1.rs file
+to move on to the next exercise."""
+
+[[exercises]]
+name = "intro2"
+path = "exercises/intro/intro2.rs"
+mode = "compile"
+hint = """
+Add an argument after the format string."""
+
# VARIABLES
[[exercises]]
@@ -5,7 +22,7 @@ name = "variables1"
path = "exercises/variables/variables1.rs"
mode = "compile"
hint = """
-Hint: The declaration on line 12 is missing a keyword that is needed in Rust
+The declaration on line 8 is missing a keyword that is needed in Rust
to create a new variable binding."""
[[exercises]]
@@ -26,33 +43,33 @@ name = "variables3"
path = "exercises/variables/variables3.rs"
mode = "compile"
hint = """
-In Rust, variable bindings are immutable by default. But here we're trying
-to reassign a different value to x! There's a keyword we can use to make
-a variable binding mutable instead."""
-
-[[exercises]]
-name = "variables4"
-path = "exercises/variables/variables4.rs"
-mode = "compile"
-hint = """
Oops! In this exercise, we have a variable binding that we've created on
line 7, and we're trying to use it on line 8, but we haven't given it a
value. We can't print out something that isn't there; try giving x a value!
This is an error that can cause bugs that's very easy to make in any
programming language -- thankfully the Rust compiler has caught this for us!"""
+[[exercises]]
+name = "variables4"
+path = "exercises/variables/variables4.rs"
+mode = "compile"
+hint = """
+In Rust, variable bindings are immutable by default. But here we're trying
+to reassign a different value to x! There's a keyword we can use to make
+a variable binding mutable instead."""
+
[[exercises]]
name = "variables5"
path = "exercises/variables/variables5.rs"
mode = "compile"
hint = """
-In variables3 we already learned how to make an immutable variable mutable
+In variables4 we already learned how to make an immutable variable mutable
using a special keyword. Unfortunately this doesn't help us much in this exercise
because we want to assign a different typed value to an existing variable. Sometimes
you may also like to reuse existing variable names because you are just converting
values to different types like in this exercise.
Fortunately Rust has a powerful solution to this problem: 'Shadowing'!
-You can read more about 'Shadowing' in the book's section 'Variables and Mutability':
+You can read more about 'Shadowing' in the book's section 'Variables and Mutability':
https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#shadowing
Try to solve this exercise afterwards using this technique."""
@@ -61,41 +78,16 @@ name = "variables6"
path = "exercises/variables/variables6.rs"
mode = "compile"
hint = """
-We know about variables and mutability, but there is another important type of
-variable available; constants.
-Constants are always immutable and they are declared with keyword 'const' rather
-then keyword 'let'.
+We know about variables and mutability, but there is another important type of
+variable available: constants.
+Constants are always immutable and they are declared with keyword 'const' rather
+than keyword 'let'.
Constants types must also always be annotated.
-Read more about constants under 'Differences Between Variables and Constants' in the book's section 'Variables and Mutability':
-https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#differences-between-variables-and-constants
+Read more about constants and the differences between variables and constants under 'Constants' in the book's section 'Variables and Mutability':
+https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html#constants
"""
-# IF
-
-[[exercises]]
-name = "if1"
-path = "exercises/if/if1.rs"
-mode = "test"
-hint = """
-It's possible to do this in one line if you would like!
-Some similar examples from other languages:
-- In C(++) this would be: `a > b ? a : b`
-- In Python this would be: `a if a > b else b`
-Remember in Rust that:
-- the `if` condition does not need to be surrounded by parentheses
-- `if`/`else` conditionals are expressions
-- Each condition is followed by a `{}` block."""
-
-[[exercises]]
-name = "if2"
-path = "exercises/if/if2.rs"
-mode = "test"
-hint = """
-For that first compiler error, it's important in Rust that each conditional
-block return the same type! To get the tests passing, you will need a couple
-conditions checking different input values."""
-
# FUNCTIONS
[[exercises]]
@@ -122,16 +114,21 @@ path = "exercises/functions/functions3.rs"
mode = "compile"
hint = """
This time, the function *declaration* is okay, but there's something wrong
-with the place where we're calling the function."""
+with the place where we're calling the function.
+As a reminder, you can freely play around with different solutions in Rustlings!
+Watch mode will only jump to the next exercise if you remove the I AM NOT DONE comment."""
[[exercises]]
name = "functions4"
path = "exercises/functions/functions4.rs"
mode = "compile"
hint = """
-The error message points to line 14 and says it expects a type after the
-`->`. This is where the function's return type should be-- take a look at
-the `is_even` function for an example!"""
+The error message points to line 17 and says it expects a type after the
+`->`. This is where the function's return type should be -- take a look at
+the `is_even` function for an example!
+
+Also: Did you figure out that, technically, u32 would be the more fitting type
+for the prices here, since they can't be negative? If so, kudos!"""
[[exercises]]
name = "functions5"
@@ -139,14 +136,45 @@ path = "exercises/functions/functions5.rs"
mode = "compile"
hint = """
This is a really common error that can be fixed by removing one character.
-It happens because Rust distinguishes between expressions and statements: expressions return
-a value based on its operand, and statements simply return a () type which behaves just like `void` in C/C++ language.
+It happens because Rust distinguishes between expressions and statements: expressions return a value based on their operand(s), and statements simply return a () type which behaves just like `void` in C/C++ language.
We want to return a value of `i32` type from the `square` function, but it is returning a `()` type...
They are not the same. There are two solutions:
1. Add a `return` ahead of `num * num;`
2. remove `;`, make it to be `num * num`"""
-# TEST 1
+# IF
+
+[[exercises]]
+name = "if1"
+path = "exercises/if/if1.rs"
+mode = "test"
+hint = """
+It's possible to do this in one line if you would like!
+Some similar examples from other languages:
+- In C(++) this would be: `a > b ? a : b`
+- In Python this would be: `a if a > b else b`
+Remember in Rust that:
+- the `if` condition does not need to be surrounded by parentheses
+- `if`/`else` conditionals are expressions
+- Each condition is followed by a `{}` block."""
+
+[[exercises]]
+name = "if2"
+path = "exercises/if/if2.rs"
+mode = "test"
+hint = """
+For that first compiler error, it's important in Rust that each conditional
+block returns the same type! To get the tests passing, you will need a couple
+conditions checking different input values."""
+
+[[exercises]]
+name = "if3"
+path = "exercises/if/if3.rs"
+mode = "test"
+hint = """
+In Rust, every arm of an `if` expression has to return the same type of value. Make sure the type is consistent across all arms."""
+
+# QUIZ 1
[[exercises]]
name = "quiz1"
@@ -193,8 +221,8 @@ that you want to end up in the slice.
If you're curious why the first argument of `assert_eq!` does not
have an ampersand for a reference since the second argument is a
-reference, take a look at the Deref coercions section of the book:
-https://doc.rust-lang.org/book/ch15-02-deref.html"""
+reference, take a look at the coercion chapter of the nomicon:
+https://doc.rust-lang.org/nomicon/coercions.html"""
[[exercises]]
name = "primitive_types5"
@@ -210,7 +238,7 @@ of the tuple. You can do it!!"""
[[exercises]]
name = "primitive_types6"
path = "exercises/primitive_types/primitive_types6.rs"
-mode = "compile"
+mode = "test"
hint = """
While you could use a destructuring `let` for the tuple here, try
indexing into it instead, as explained in the last example of the
@@ -218,6 +246,124 @@ Data Types -> The Tuple Type section of the book:
https://doc.rust-lang.org/book/ch03-02-data-types.html#the-tuple-type
Now you have another tool in your toolbox!"""
+# VECS
+
+[[exercises]]
+name = "vecs1"
+path = "exercises/vecs/vecs1.rs"
+mode = "test"
+hint = """
+In Rust, there are two ways to define a Vector.
+1. One way is to use the `Vec::new()` function to create a new vector
+ and fill it with the `push()` method.
+2. The second way, which is simpler is to use the `vec![]` macro and
+ define your elements inside the square brackets.
+Check this chapter: https://doc.rust-lang.org/stable/book/ch08-01-vectors.html
+of the Rust book to learn more.
+"""
+
+[[exercises]]
+name = "vecs2"
+path = "exercises/vecs/vecs2.rs"
+mode = "test"
+hint = """
+Hint 1: In the code, the variable `element` represents an item from the Vec as it is being iterated.
+Can you try multiplying this?
+
+Hint 2: For the first function, there's a way to directly access the numbers stored
+in the Vec, using the * dereference operator. You can both access and write to the
+number that way.
+
+After you've completed both functions, decide for yourself which approach you like
+better. What do you think is the more commonly used pattern under Rust developers?
+"""
+
+# MOVE SEMANTICS
+
+[[exercises]]
+name = "move_semantics1"
+path = "exercises/move_semantics/move_semantics1.rs"
+mode = "compile"
+hint = """
+So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on line 13,
+right? The fix for this is going to be adding one keyword, and the addition is NOT on line 13
+where the error is.
+
+Also: Try accessing `vec0` after having called `fill_vec()`. See what happens!"""
+
+[[exercises]]
+name = "move_semantics2"
+path = "exercises/move_semantics/move_semantics2.rs"
+mode = "compile"
+hint = """
+When running this exercise for the first time, you'll notice an error about
+"borrow of moved value". In Rust, when an argument is passed to a function and
+it's not explicitly returned, you can't use the original variable anymore.
+We call this "moving" a variable. When we pass `vec0` into `fill_vec`, it's being
+"moved" into `vec1`, meaning we can't access `vec0` anymore after the fact.
+Rust provides a couple of different ways to mitigate this issue, feel free to try them all:
+1. You could make another, separate version of the data that's in `vec0` and pass that
+ to `fill_vec` instead.
+2. Make `fill_vec` borrow its argument instead of taking ownership of it,
+ and then copy the data within the function (`vec.clone()`) in order to return an owned
+ `Vec`.
+3. Or, you could make `fill_vec` *mutably* borrow a reference to its argument (which will need to be
+ mutable), modify it directly, then not return anything. This means that `vec0` will change over the
+ course of the function, and makes `vec1` redundant (make sure to change the parameters of the `println!`
+ statements if you go this route)
+"""
+
+[[exercises]]
+name = "move_semantics3"
+path = "exercises/move_semantics/move_semantics3.rs"
+mode = "compile"
+hint = """
+The difference between this one and the previous ones is that the first line
+of `fn fill_vec` that had `let mut vec = vec;` is no longer there. You can,
+instead of adding that line back, add `mut` in one place that will change
+an existing binding to be a mutable binding instead of an immutable one :)"""
+
+[[exercises]]
+name = "move_semantics4"
+path = "exercises/move_semantics/move_semantics4.rs"
+mode = "compile"
+hint = """
+Stop reading whenever you feel like you have enough direction :) Or try
+doing one step and then fixing the compiler errors that result!
+So the end goal is to:
+ - get rid of the first line in main that creates the new vector
+ - so then `vec0` doesn't exist, so we can't pass it to `fill_vec`
+ - `fill_vec` has had its signature changed, which our call should reflect
+ - since we're not creating a new vec in `main` anymore, we need to create
+ a new vec in `fill_vec`, similarly to the way we did in `main`"""
+
+[[exercises]]
+name = "move_semantics5"
+path = "exercises/move_semantics/move_semantics5.rs"
+mode = "compile"
+hint = """
+Carefully reason about the range in which each mutable reference is in
+scope. Does it help to update the value of referent (x) immediately after
+the mutable reference is taken? Read more about 'Mutable References'
+in the book's section References and Borrowing':
+https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html#mutable-references.
+"""
+
+[[exercises]]
+name = "move_semantics6"
+path = "exercises/move_semantics/move_semantics6.rs"
+mode = "compile"
+hint = """
+To find the answer, you can consult the book section "References and Borrowing":
+https://doc.rust-lang.org/stable/book/ch04-02-references-and-borrowing.html
+The first problem is that `get_char` is taking ownership of the string.
+So `data` is moved and can't be used for `string_uppercase`
+`data` is moved to `get_char` first, meaning that `string_uppercase` cannot manipulate the data.
+Once you've fixed that, `string_uppercase`'s function signature will also need to be adjusted.
+Can you figure out how?
+
+Another hint: it has to do with the `&` character."""
+
# STRUCTS
[[exercises]]
@@ -225,20 +371,21 @@ name = "structs1"
path = "exercises/structs/structs1.rs"
mode = "test"
hint = """
-Rust has more than one type of struct. Both variants are used to package related data together.
-On the one hand, there are normal, or classic, structs. These are named collections of related data stored in fields.
-The other variant is tuple structs. Basically just named tuples.
-In this exercise you need to implement one of each kind.
+Rust has more than one type of struct. Three actually, all variants are used to package related data together.
+There are normal (or classic) structs. These are named collections of related data stored in fields.
+Tuple structs are basically just named tuples.
+Finally, Unit-like structs. These don't have any fields and are useful for generics.
-Read more about structs in The Book: https://doc.rust-lang.org/stable/book/ch05-00-structs.html"""
+In this exercise you need to complete and implement one of each kind.
+Read more about structs in The Book: https://doc.rust-lang.org/book/ch05-01-defining-structs.html"""
[[exercises]]
name = "structs2"
path = "exercises/structs/structs2.rs"
mode = "test"
hint = """
-Creating instances of structs is easy, all you need to do is assign some values to its fields.
-There is however some shortcuts that can be taken when instantiating structs.
+Creating instances of structs is easy, all you need to do is assign some values to its fields.
+There are however some shortcuts that can be taken when instantiating structs.
Have a look in The Book, to find out more: https://doc.rust-lang.org/stable/book/ch05-01-defining-structs.html#creating-instances-from-other-instances-with-struct-update-syntax"""
[[exercises]]
@@ -246,14 +393,38 @@ name = "structs3"
path = "exercises/structs/structs3.rs"
mode = "test"
hint = """
-The new method needs to panic if the weight is physically impossible :), how do we do that in Rust?
-
For is_international: What makes a package international? Seems related to the places it goes through right?
-For calculate_transport_fees: Bigger is more expensive usually, we don't have size, but something may fit the bill here :)
+For get_fees: This method takes an additional argument, is there a field in the Package struct that this relates to?
Have a look in The Book, to find out more about method implementations: https://doc.rust-lang.org/book/ch05-03-method-syntax.html"""
+# ENUMS
+
+[[exercises]]
+name = "enums1"
+path = "exercises/enums/enums1.rs"
+mode = "compile"
+hint = "No hints this time ;)"
+
+[[exercises]]
+name = "enums2"
+path = "exercises/enums/enums2.rs"
+mode = "compile"
+hint = """
+You can create enumerations that have different variants with different types
+such as no data, anonymous structs, a single string, tuples, ...etc"""
+
+[[exercises]]
+name = "enums3"
+path = "exercises/enums/enums3.rs"
+mode = "test"
+hint = """
+As a first step, you can define enums to compile this code without errors.
+and then create a match expression in `process()`.
+Note that you need to deconstruct some message variants
+in the match expression to get value in the variant."""
+
# STRINGS
[[exercises]]
@@ -275,39 +446,343 @@ mode = "compile"
hint = """
Yes, it would be really easy to fix this by just changing the value bound to `word` to be a
string slice instead of a `String`, wouldn't it?? There is a way to add one character to line
-9, though, that will coerce the `String` into a string slice."""
+12, though, that will coerce the `String` into a string slice.
-# TEST 2
+Side note: If you're interested in learning about how this kind of reference conversion works, you can jump ahead in the book and read this part in the smart pointers chapter: https://doc.rust-lang.org/stable/book/ch15-02-deref.html#implicit-deref-coercions-with-functions-and-methods"""
+
+[[exercises]]
+name = "strings3"
+path = "exercises/strings/strings3.rs"
+mode = "test"
+hint = """
+There's tons of useful standard library functions for strings. Let's try and use some of
+them: !
+
+For the compose_me method: You can either use the `format!` macro, or convert the string
+slice into an owned string, which you can then freely extend."""
+
+[[exercises]]
+name = "strings4"
+path = "exercises/strings/strings4.rs"
+mode = "compile"
+hint = "No hints this time ;)"
+
+# MODULES
+
+[[exercises]]
+name = "modules1"
+path = "exercises/modules/modules1.rs"
+mode = "compile"
+hint = """
+Everything is private in Rust by default-- but there's a keyword we can use
+to make something public! The compiler error should point to the thing that
+needs to be public."""
+
+[[exercises]]
+name = "modules2"
+path = "exercises/modules/modules2.rs"
+mode = "compile"
+hint = """
+The delicious_snacks module is trying to present an external interface that is
+different than its internal structure (the `fruits` and `veggies` modules and
+associated constants). Complete the `use` statements to fit the uses in main and
+find the one keyword missing for both constants.
+Learn more at https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#re-exporting-names-with-pub-use"""
+
+[[exercises]]
+name = "modules3"
+path = "exercises/modules/modules3.rs"
+mode = "compile"
+hint = """
+UNIX_EPOCH and SystemTime are declared in the std::time module. Add a use statement
+for these two to bring them into scope. You can use nested paths or the glob
+operator to bring these two in using only one line."""
+
+# HASHMAPS
+
+[[exercises]]
+name = "hashmaps1"
+path = "exercises/hashmaps/hashmaps1.rs"
+mode = "test"
+hint = """
+Hint 1: Take a look at the return type of the function to figure out
+ the type for the `basket`.
+Hint 2: Number of fruits should be at least 5. And you have to put
+ at least three different types of fruits.
+"""
+
+[[exercises]]
+name = "hashmaps2"
+path = "exercises/hashmaps/hashmaps2.rs"
+mode = "test"
+hint = """
+Use the `entry()` and `or_insert()` methods of `HashMap` to achieve this.
+Learn more at https://doc.rust-lang.org/stable/book/ch08-03-hash-maps.html#only-inserting-a-value-if-the-key-has-no-value
+"""
+
+[[exercises]]
+name = "hashmaps3"
+path = "exercises/hashmaps/hashmaps3.rs"
+mode = "test"
+hint = """
+Hint 1: Use the `entry()` and `or_insert()` methods of `HashMap` to insert entries corresponding to each team in the scores table.
+Learn more at https://doc.rust-lang.org/stable/book/ch08-03-hash-maps.html#only-inserting-a-value-if-the-key-has-no-value
+Hint 2: If there is already an entry for a given key, the value returned by `entry()` can be updated based on the existing value.
+Learn more at https://doc.rust-lang.org/book/ch08-03-hash-maps.html#updating-a-value-based-on-the-old-value
+"""
+
+# QUIZ 2
[[exercises]]
name = "quiz2"
path = "exercises/quiz2.rs"
-mode = "compile"
-hint = "No hints this time ;)"
-
-# ENUMS
-
-[[exercises]]
-name = "enums1"
-path = "exercises/enums/enums1.rs"
-mode = "compile"
-hint = """
-Hint: The declaration of the enumeration type has not been defined yet."""
-
-[[exercises]]
-name = "enums2"
-path = "exercises/enums/enums2.rs"
-mode = "compile"
-hint = """
-Hint: you can create enumerations that have different variants with different types
-such as no data, anonymous structs, a single string, tuples, ...etc"""
-
-[[exercises]]
-name = "enums3"
-path = "exercises/enums/enums3.rs"
mode = "test"
hint = "No hints this time ;)"
+# OPTIONS
+
+[[exercises]]
+name = "options1"
+path = "exercises/options/options1.rs"
+mode = "test"
+hint = """
+Options can have a Some value, with an inner value, or a None value, without an inner value.
+There's multiple ways to get at the inner value, you can use unwrap, or pattern match. Unwrapping
+is the easiest, but how do you do it safely so that it doesn't panic in your face later?"""
+
+[[exercises]]
+name = "options2"
+path = "exercises/options/options2.rs"
+mode = "test"
+hint = """
+check out:
+https://doc.rust-lang.org/rust-by-example/flow_control/if_let.html
+https://doc.rust-lang.org/rust-by-example/flow_control/while_let.html
+
+Remember that Options can be stacked in if let and while let.
+For example: Some(Some(variable)) = variable2
+Also see Option::flatten
+"""
+
+[[exercises]]
+name = "options3"
+path = "exercises/options/options3.rs"
+mode = "compile"
+hint = """
+The compiler says a partial move happened in the `match`
+statement. How can this be avoided? The compiler shows the correction
+needed. After making the correction as suggested by the compiler, do
+read: https://doc.rust-lang.org/std/keyword.ref.html"""
+
+# ERROR HANDLING
+
+[[exercises]]
+name = "errors1"
+path = "exercises/error_handling/errors1.rs"
+mode = "test"
+hint = """
+`Ok` and `Err` are one of the variants of `Result`, so what the tests are saying
+is that `generate_nametag_text` should return a `Result` instead of an
+`Option`.
+
+To make this change, you'll need to:
+ - update the return type in the function signature to be a Result that
+ could be the variants `Ok(String)` and `Err(String)`
+ - change the body of the function to return `Ok(stuff)` where it currently
+ returns `Some(stuff)`
+ - change the body of the function to return `Err(error message)` where it
+ currently returns `None`"""
+
+[[exercises]]
+name = "errors2"
+path = "exercises/error_handling/errors2.rs"
+mode = "test"
+hint = """
+One way to handle this is using a `match` statement on
+`item_quantity.parse::()` where the cases are `Ok(something)` and
+`Err(something)`. This pattern is very common in Rust, though, so there's
+a `?` operator that does pretty much what you would make that match statement
+do for you! Take a look at this section of the Error Handling chapter:
+https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
+and give it a try!"""
+
+[[exercises]]
+name = "errors3"
+path = "exercises/error_handling/errors3.rs"
+mode = "compile"
+hint = """
+If other functions can return a `Result`, why shouldn't `main`? It's a fairly common
+convention to return something like Result<(), ErrorType> from your main function.
+The unit (`()`) type is there because nothing is really needed in terms of positive
+results."""
+
+[[exercises]]
+name = "errors4"
+path = "exercises/error_handling/errors4.rs"
+mode = "test"
+hint = """
+`PositiveNonzeroInteger::new` is always creating a new instance and returning an `Ok` result.
+It should be doing some checking, returning an `Err` result if those checks fail, and only
+returning an `Ok` result if those checks determine that everything is... okay :)"""
+
+[[exercises]]
+name = "errors5"
+path = "exercises/error_handling/errors5.rs"
+mode = "compile"
+hint = """
+There are two different possible `Result` types produced within `main()`, which are
+propagated using `?` operators. How do we declare a return type from `main()` that allows both?
+
+Under the hood, the `?` operator calls `From::from` on the error value to convert it to a boxed
+trait object, a `Box`. This boxed trait object is polymorphic, and since all
+errors implement the `error::Error` trait, we can capture lots of different errors in one "Box"
+object.
+
+Check out this section of the book:
+https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
+
+Read more about boxing errors:
+https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/boxing_errors.html
+
+Read more about using the `?` operator with boxed errors:
+https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reenter_question_mark.html
+"""
+
+[[exercises]]
+name = "errors6"
+path = "exercises/error_handling/errors6.rs"
+mode = "test"
+hint = """
+This exercise uses a completed version of `PositiveNonzeroInteger` from
+errors4.
+
+Below the line that TODO asks you to change, there is an example of using
+the `map_err()` method on a `Result` to transform one type of error into
+another. Try using something similar on the `Result` from `parse()`. You
+might use the `?` operator to return early from the function, or you might
+use a `match` expression, or maybe there's another way!
+
+You can create another function inside `impl ParsePosNonzeroError` to use
+with `map_err()`.
+
+Read more about `map_err()` in the `std::result` documentation:
+https://doc.rust-lang.org/std/result/enum.Result.html#method.map_err"""
+
+# Generics
+
+[[exercises]]
+name = "generics1"
+path = "exercises/generics/generics1.rs"
+mode = "compile"
+hint = """
+Vectors in Rust make use of generics to create dynamically sized arrays of any type.
+You need to tell the compiler what type we are pushing onto this vector."""
+
+[[exercises]]
+name = "generics2"
+path = "exercises/generics/generics2.rs"
+mode = "test"
+hint = """
+Currently we are wrapping only values of type 'u32'.
+Maybe we could update the explicit references to this data type somehow?
+
+If you are still stuck https://doc.rust-lang.org/stable/book/ch10-01-syntax.html#in-method-definitions
+"""
+
+# TRAITS
+
+[[exercises]]
+name = "traits1"
+path = "exercises/traits/traits1.rs"
+mode = "test"
+hint = """
+A discussion about Traits in Rust can be found at:
+https://doc.rust-lang.org/book/ch10-02-traits.html
+"""
+
+[[exercises]]
+name = "traits2"
+path = "exercises/traits/traits2.rs"
+mode = "test"
+hint = """
+Notice how the trait takes ownership of 'self',and returns `Self`.
+Try mutating the incoming string vector. Have a look at the tests to see
+what the result should look like!
+
+Vectors provide suitable methods for adding an element at the end. See
+the documentation at: https://doc.rust-lang.org/std/vec/struct.Vec.html"""
+
+[[exercises]]
+name = "traits3"
+path = "exercises/traits/traits3.rs"
+mode = "test"
+hint = """
+Traits can have a default implementation for functions. Structs that implement
+the trait can then use the default version of these functions if they choose not
+implement the function themselves.
+
+See the documentation at: https://doc.rust-lang.org/book/ch10-02-traits.html#default-implementations
+"""
+
+[[exercises]]
+name = "traits4"
+path = "exercises/traits/traits4.rs"
+mode = "test"
+hint = """
+Instead of using concrete types as parameters you can use traits. Try replacing the
+'??' with 'impl '
+
+See the documentation at: https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
+"""
+
+[[exercises]]
+name = "traits5"
+path = "exercises/traits/traits5.rs"
+mode = "compile"
+hint = """
+To ensure a parameter implements multiple traits use the '+ syntax'. Try replacing the
+'??' with 'impl <> + <>'.
+
+See the documentation at: https://doc.rust-lang.org/book/ch10-02-traits.html#specifying-multiple-trait-bounds-with-the--syntax
+"""
+
+# QUIZ 3
+
+[[exercises]]
+name = "quiz3"
+path = "exercises/quiz3.rs"
+mode = "test"
+hint = """
+To find the best solution to this challenge you're going to need to think back to your
+knowledge of traits, specifically Trait Bound Syntax - you may also need this: `use std::fmt::Display;`."""
+
+# 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 = """
+Remember that the generic lifetime 'a will get the concrete lifetime that is equal to the smaller of the lifetimes of x and y.
+You can take at least two paths to achieve the desired result while keeping the inner block:
+1. Move the string2 declaration to make it live as long as string1 (how is result declared?)
+2. Move println! into the inner block"""
+
+[[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?"""
+
# TESTS
[[exercises]]
@@ -340,35 +815,226 @@ 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())`."""
-# TEST 3
-
[[exercises]]
-name = "quiz3"
-path = "exercises/quiz3.rs"
+name = "tests4"
+path = "exercises/tests/tests4.rs"
mode = "test"
-hint = "No hints this time ;)"
+hint = """
+We expect method `Rectangle::new()` to panic for negative values.
+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/stable/book/ch11-01-writing-tests.html#checking-for-panics-with-should_panic"""
-# MODULES
+
+# STANDARD LIBRARY TYPES
[[exercises]]
-name = "modules1"
-path = "exercises/modules/modules1.rs"
+name = "iterators1"
+path = "exercises/iterators/iterators1.rs"
mode = "compile"
hint = """
-Everything is private in Rust by default-- but there's a keyword we can use
-to make something public! The compiler error should point to the thing that
-needs to be public."""
+Step 1:
+We need to apply something to the collection `my_fav_fruits` before we start to go through
+it. What could that be? Take a look at the struct definition for a vector for inspiration:
+https://doc.rust-lang.org/std/vec/struct.Vec.html
+Step 2 & step 3:
+Very similar to the lines above and below. You've got this!
+Step 4:
+An iterator goes through all elements in a collection, but what if we've run out of
+elements? What should we expect here? If you're stuck, take a look at
+https://doc.rust-lang.org/std/iter/trait.Iterator.html for some ideas.
+"""
[[exercises]]
-name = "modules2"
-path = "exercises/modules/modules2.rs"
+name = "iterators2"
+path = "exercises/iterators/iterators2.rs"
+mode = "test"
+hint = """
+Step 1
+The variable `first` is a `char`. It needs to be capitalized and added to the
+remaining characters in `c` in order to return the correct `String`.
+The remaining characters in `c` can be viewed as a string slice using the
+`as_str` method.
+The documentation for `char` contains many useful methods.
+https://doc.rust-lang.org/std/primitive.char.html
+
+Step 2
+Create an iterator from the slice. Transform the iterated values by applying
+the `capitalize_first` function. Remember to collect the iterator.
+
+Step 3.
+This is surprisingly similar to the previous solution. Collect is very powerful
+and very general. Rust just needs to know the desired type."""
+
+[[exercises]]
+name = "iterators3"
+path = "exercises/iterators/iterators3.rs"
+mode = "test"
+hint = """
+The divide function needs to return the correct error when even division is not
+possible.
+
+The division_results variable needs to be collected into a collection type.
+
+The result_with_list function needs to return a single Result where the success
+case is a vector of integers and the failure case is a DivisionError.
+
+The list_of_results function needs to return a vector of results.
+
+See https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect for how
+the `FromIterator` trait is used in `collect()`. This trait is REALLY powerful! It
+can make the solution to this exercise infinitely easier."""
+
+[[exercises]]
+name = "iterators4"
+path = "exercises/iterators/iterators4.rs"
+mode = "test"
+hint = """
+In an imperative language, you might write a for loop that updates
+a mutable variable. Or, you might write code utilizing recursion
+and a match clause. In Rust you can take another functional
+approach, computing the factorial elegantly with ranges and iterators.
+
+Hint 2: Check out the `fold` and `rfold` methods!"""
+
+[[exercises]]
+name = "iterators5"
+path = "exercises/iterators/iterators5.rs"
+mode = "test"
+hint = """
+The documentation for the std::iter::Iterator trait contains numerous methods
+that would be helpful here.
+
+The collection variable in count_collection_iterator is a slice of HashMaps. It
+needs to be converted into an iterator in order to use the iterator methods.
+
+The fold method can be useful in the count_collection_iterator function.
+
+For a further challenge, consult the documentation for Iterator to find
+a different method that could make your code more compact than using fold."""
+
+# SMART POINTERS
+
+[[exercises]]
+name = "box1"
+path = "exercises/smart_pointers/box1.rs"
+mode = "test"
+hint = """
+Step 1
+The compiler's message should help: since we cannot store the value of the actual type
+when working with recursive types, we need to store a reference (pointer) to its value.
+We should, therefore, place our `List` inside a `Box`. More details in the book here:
+https://doc.rust-lang.org/book/ch15-01-box.html#enabling-recursive-types-with-boxes
+
+Step 2
+Creating an empty list should be fairly straightforward (hint: peek at the assertions).
+For a non-empty list keep in mind that we want to use our Cons "list builder".
+Although the current list is one of integers (i32), feel free to change the definition
+and try other types!
+"""
+
+[[exercises]]
+name = "rc1"
+path = "exercises/smart_pointers/rc1.rs"
mode = "compile"
hint = """
-The delicious_snacks module is trying to present an external
-interface (the `fruit` and `veggie` constants) that is different than
-its internal structure (the `fruits` and `veggies` modules and
-associated constants). It's almost there except for one keyword missing for
-each constant."""
+This is a straightforward exercise to use the Rc type. Each Planet has
+ownership of the Sun, and uses Rc::clone() to increment the reference count of the Sun.
+After using drop() to move the Planets out of scope individually, the reference count goes down.
+In the end the sun only has one reference again, to itself. See more at:
+https://doc.rust-lang.org/book/ch15-04-rc.html
+
+* Unfortunately Pluto is no longer considered a planet :(
+"""
+
+[[exercises]]
+name = "arc1"
+path = "exercises/smart_pointers/arc1.rs"
+mode = "compile"
+hint = """
+Make `shared_numbers` be an `Arc` from the numbers vector. Then, in order
+to avoid creating a copy of `numbers`, you'll need to create `child_numbers`
+inside the loop but still in the main thread.
+
+`child_numbers` should be a clone of the Arc of the numbers instead of a
+thread-local copy of the numbers.
+
+This is a simple exercise if you understand the underlying concepts, but if this
+is too much of a struggle, consider reading through all of Chapter 16 in the book:
+https://doc.rust-lang.org/stable/book/ch16-00-concurrency.html
+"""
+
+[[exercises]]
+name = "cow1"
+path = "exercises/smart_pointers/cow1.rs"
+mode = "test"
+hint = """
+If Cow already owns the data it doesn't need to clone it when to_mut() is called.
+
+Check out https://doc.rust-lang.org/std/borrow/enum.Cow.html for documentation
+on the `Cow` type.
+"""
+
+# THREADS
+
+[[exercises]]
+name = "threads1"
+path = "exercises/threads/threads1.rs"
+mode = "compile"
+hint = """
+`JoinHandle` is a struct that is returned from a spawned thread:
+https://doc.rust-lang.org/std/thread/fn.spawn.html
+
+A challenge with multi-threaded applications is that the main thread can
+finish before the spawned threads are completed.
+https://doc.rust-lang.org/book/ch16-01-threads.html#waiting-for-all-threads-to-finish-using-join-handles
+
+Use the JoinHandles to wait for each thread to finish and collect their results.
+https://doc.rust-lang.org/std/thread/struct.JoinHandle.html
+"""
+
+[[exercises]]
+name = "threads2"
+path = "exercises/threads/threads2.rs"
+mode = "compile"
+hint = """
+`Arc` is an Atomic Reference Counted pointer that allows safe, shared access
+to **immutable** data. But we want to *change* the number of `jobs_completed`
+so we'll need to also use another type that will only allow one thread to
+mutate the data at a time. Take a look at this section of the book:
+https://doc.rust-lang.org/book/ch16-03-shared-state.html#atomic-reference-counting-with-arct
+and keep reading if you'd like more hints :)
+
+
+Do you now have an `Arc` `Mutex` `JobStatus` at the beginning of main? Like:
+`let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));`
+Similar to the code in the example in the book that happens after the text
+that says "We can use Arc to fix this.". If not, give that a try! If you
+do and would like more hints, keep reading!!
+
+
+Make sure neither of your threads are holding onto the lock of the mutex
+while they are sleeping, since this will prevent the other thread from
+being allowed to get the lock. Locks are automatically released when
+they go out of scope.
+
+If you've learned from the sample solutions, I encourage you to come
+back to this exercise and try it again in a few days to reinforce
+what you've learned :)"""
+
+[[exercises]]
+name = "threads3"
+path = "exercises/threads/threads3.rs"
+mode = "compile"
+hint = """
+An alternate way to handle concurrency between threads is to use
+a mpsc (multiple producer, single consumer) channel to communicate.
+With both a sending end and a receiving end, it's possible to
+send values in one thread and receive them in another.
+Multiple producers are possible by using clone() to create a duplicate
+of the original sending end.
+See https://doc.rust-lang.org/book/ch16-02-message-passing.html for more info.
+"""
# MACROS
@@ -410,191 +1076,12 @@ mode = "compile"
hint = """
You only need to add a single character to make this compile.
The way macros are written, it wants to see something between each
-"macro arm", so it can separate them."""
-# TEST 4
+"macro arm", so it can separate them.
-[[exercises]]
-name = "quiz4"
-path = "exercises/quiz4.rs"
-mode = "test"
-hint = "No hints this time ;)"
-
-# MOVE SEMANTICS
-
-[[exercises]]
-name = "move_semantics1"
-path = "exercises/move_semantics/move_semantics1.rs"
-mode = "compile"
-hint = """
-So you've got the "cannot borrow immutable local variable `vec1` as mutable" error on line 13,
-right? The fix for this is going to be adding one keyword, and the addition is NOT on line 13
-where the error is."""
-
-[[exercises]]
-name = "move_semantics2"
-path = "exercises/move_semantics/move_semantics2.rs"
-mode = "compile"
-hint = """
-So `vec0` is being *moved* into the function `fill_vec` when we call it on
-line 10, which means it gets dropped at the end of `fill_vec`, which means we
-can't use `vec0` again on line 13 (or anywhere else in `main` after the
-`fill_vec` call for that matter). We could fix this in a few ways, try them
-all!
-1. Make another, separate version of the data that's in `vec0` and pass that
- to `fill_vec` instead.
-2. Make `fill_vec` borrow its argument instead of taking ownership of it,
- and then copy the data within the function in order to return an owned
- `Vec`
-3. Make `fill_vec` *mutably* borrow its argument (which will need to be
- mutable), modify it directly, then not return anything. Then you can get rid
- of `vec1` entirely -- note that this will change what gets printed by the
- first `println!`"""
-
-[[exercises]]
-name = "move_semantics3"
-path = "exercises/move_semantics/move_semantics3.rs"
-mode = "compile"
-hint = """
-The difference between this one and the previous ones is that the first line
-of `fn fill_vec` that had `let mut vec = vec;` is no longer there. You can,
-instead of adding that line back, add `mut` in one place that will change
-an existing binding to be a mutable binding instead of an immutable one :)"""
-
-[[exercises]]
-name = "move_semantics4"
-path = "exercises/move_semantics/move_semantics4.rs"
-mode = "compile"
-hint = """
-Stop reading whenever you feel like you have enough direction :) Or try
-doing one step and then fixing the compiler errors that result!
-So the end goal is to:
- - get rid of the first line in main that creates the new vector
- - so then `vec0` doesn't exist, so we can't pass it to `fill_vec`
- - we don't want to pass anything to `fill_vec`, so its signature should
- reflect that it does not take any arguments
- - since we're not creating a new vec in `main` anymore, we need to create
- a new vec in `fill_vec`, similarly to the way we did in `main`"""
-
-# ERROR HANDLING
-
-[[exercises]]
-name = "errors1"
-path = "exercises/error_handling/errors1.rs"
-mode = "test"
-hint = """
-`Err` is one of the variants of `Result`, so what the 2nd test is saying
-is that `generate_nametag_text` should return a `Result` instead of an
-`Option`.
-
-To make this change, you'll need to:
- - update the return type in the function signature to be a Result that
- could be the variants `Ok(String)` and `Err(String)`
- - change the body of the function to return `Ok(stuff)` where it currently
- returns `Some(stuff)`
- - change the body of the function to return `Err(error message)` where it
- currently returns `None`
- - change the first test to expect `Ok(stuff)` where it currently expects
- `Some(stuff)`."""
-
-[[exercises]]
-name = "errors2"
-path = "exercises/error_handling/errors2.rs"
-mode = "test"
-hint = """
-One way to handle this is using a `match` statement on
-`item_quantity.parse::()` where the cases are `Ok(something)` and
-`Err(something)`. This pattern is very common in Rust, though, so there's
-a `?` operator that does pretty much what you would make that match statement
-do for you! Take a look at this section of the Error Handling chapter:
-https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
-and give it a try!"""
-
-[[exercises]]
-name = "errors3"
-path = "exercises/error_handling/errors3.rs"
-mode = "test"
-hint = """
-If other functions can return a `Result`, why shouldn't `main`?"""
-
-[[exercises]]
-name = "errorsn"
-path = "exercises/error_handling/errorsn.rs"
-mode = "test"
-hint = """
-First hint: To figure out what type should go where the ??? is, take a look
-at the test helper function `test_with_str`, since it returns whatever
-`read_and_validate` returns and `test_with_str` has its signature fully
-specified.
-
-
-Next hint: There are three places in `read_and_validate` that we call a
-function that returns a `Result` (that is, the functions might fail).
-Apply the `?` operator on those calls so that we return immediately from
-`read_and_validate` if those function calls fail.
-
-
-Another hint: under the hood, the `?` operator calls `From::from`
-on the error value to convert it to a boxed trait object, a Box,
-which is polymorphic-- that means that lots of different kinds of errors
-can be returned from the same function because all errors act the same
-since they all implement the `error::Error` trait.
-Check out this section of the book:
-https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#a-shortcut-for-propagating-errors-the--operator
-
-
-Another another hint: Note that because the `?` operator returns
-the *unwrapped* value in the `Ok` case, if we want to return a `Result` from
-`read_and_validate` for *its* success case, we'll have to rewrap a value
-that we got from the return value of a `?`ed call in an `Ok`-- this will
-look like `Ok(something)`.
-
-
-Another another another hint: `Result`s must be "used", that is, you'll
-get a warning if you don't handle a `Result` that you get in your
-function. Read more about that in the `std::result` module docs:
-https://doc.rust-lang.org/std/result/#results-must-be-used"""
-
-# OPTIONS / RESULTS
-
-[[exercises]]
-name = "option1"
-path = "exercises/option/option1.rs"
-mode = "compile"
-hint = """
-Hint 1: Check out some functions of Option:
-is_some
-is_none
-unwrap
-
-and:
-pattern matching
-
-Hint 2: There are no sensible defaults for the value of an Array; the values need to be filled before use.
-"""
-
-[[exercises]]
-name = "option2"
-path = "exercises/option/option2.rs"
-mode = "compile"
-hint = """
-check out:
-https://doc.rust-lang.org/rust-by-example/flow_control/if_let.html
-https://doc.rust-lang.org/rust-by-example/flow_control/while_let.html
-
-Remember that Options can be stacked in if let and while let.
-For example: Some(Some(variable)) = variable2
-
-
-"""
-
-[[exercises]]
-name = "result1"
-path = "exercises/error_handling/result1.rs"
-mode = "test"
-hint = """
-`PositiveNonzeroInteger::new` is always creating a new instance and returning an `Ok` result.
-It should be doing some checking, returning an `Err` result if those checks fail, and only
-returning an `Ok` result if those checks determine that everything is... okay :)"""
+That's all the macro exercises we have in here, but it's barely even
+scratching the surface of what you can do with Rust's macros. For a more
+thorough introduction, you can have a read through the little book of Rust
+macros: https://veykril.github.io/tlborm/"""
# CLIPPY
@@ -603,7 +1090,15 @@ name = "clippy1"
path = "exercises/clippy/clippy1.rs"
mode = "clippy"
hint = """
-Floating point calculations are usually imprecise, so asking if two values are exactly equal is asking for trouble"""
+Rust stores the highest precision version of any long or infinite precision
+mathematical constants in the Rust standard library.
+https://doc.rust-lang.org/stable/std/f32/consts/index.html
+
+We may be tempted to use our own approximations for certain mathematical constants,
+but clippy recognizes those imprecise mathematical constants as a source of
+potential error.
+See the suggestions of the clippy warning in compile output and use the
+appropriate replacement constant from std::f32::consts..."""
[[exercises]]
name = "clippy2"
@@ -612,182 +1107,18 @@ mode = "clippy"
hint = """
`for` loops over Option values are more clearly expressed as an `if let`"""
-# STANDARD LIBRARY TYPES
-
[[exercises]]
-name = "box1"
-path = "exercises/standard_library_types/box1.rs"
-mode = "test"
-hint = """
-Step 1
-The compiler's message should help: since we cannot store the value of the actual type
-when working with recursive types, we need to store a reference (pointer) to its value.
-We should, therefore, place our `List` inside a `Box`. More details in the book here:
-https://doc.rust-lang.org/book/ch15-01-box.html#enabling-recursive-types-with-boxes
-
-Step 2
-Creating an empty list should be fairly straightforward (hint: peek at the assertions).
-For a non-empty list keep in mind that we want to use our Cons "list builder".
-Although the current list is one of integers (i32), feel free to change the definition
-and try other types!
-"""
-
-[[exercises]]
-name = "arc1"
-path = "exercises/standard_library_types/arc1.rs"
-mode = "compile"
-hint = """
-Make `shared_numbers` be an `Arc` from the numbers vector. Then, in order
-to avoid creating a copy of `numbers`, you'll need to create `child_numbers`
-inside the loop but still in the main thread.
-
-`child_numbers` should be a clone of the Arc of the numbers instead of a
-thread-local copy of the numbers."""
-
-[[exercises]]
-name = "iterators2"
-path = "exercises/standard_library_types/iterators2.rs"
-mode = "test"
-hint = """
-Step 1
-You need to call something on `first` before it can be collected
-Currently its type is `char`. Have a look at the methods that are available on that type:
-https://doc.rust-lang.org/std/primitive.char.html
-
-
-Step 2
-First you'll need to turn the Vec into an iterator
-Then you'll need to apply your function unto each item in the vector
-P.s. Don't forget to collect() at the end!
-
-
-Step 3.
-This is very similar to the previous test. The only real change is that you will need to
-alter the type that collect is coerced into. For a bonus you could try doing this with a
-turbofish"""
-
-[[exercises]]
-name = "iterators3"
-path = "exercises/standard_library_types/iterators3.rs"
-mode = "test"
-hint = """
-Minor hint: In each of the two cases in the match in main, you can create x with either
-a 'turbofish' or by hinting the type of x to the compiler. You may try both.
-
-Major hint: Have a look at the Iter trait and at the explanation of its collect function.
-Especially the part about Result is interesting."""
-
-[[exercises]]
-name = "iterators4"
-path = "exercises/standard_library_types/iterators4.rs"
-mode = "test"
-hint = """
-In an imperative language, you might write a for loop that updates
-a mutable variable. Or, you might write code utilizing recursion
-and a match clause. In Rust you can take another functional
-approach, computing the factorial elegantly with ranges and iterators."""
-
-# TRAITS
-
-[[exercises]]
-name = "traits1"
-path = "exercises/traits/traits1.rs"
-mode = "test"
-hint = """
-A discussion about Traits in Rust can be found at:
-https://doc.rust-lang.org/book/ch10-02-traits.html
-"""
-
-[[exercises]]
-name = "traits2"
-path = "exercises/traits/traits2.rs"
-mode = "test"
-hint = """
-Notice how the trait takes ownership of 'self',and returns `Self'.
-Try mutating the incoming string vector.
-
-Vectors provide suitable methods for adding an element at the end. See
-the documentation at: https://doc.rust-lang.org/std/vec/struct.Vec.html"""
-
-# Generics
-
-[[exercises]]
-name = "generics1"
-path = "exercises/generics/generics1.rs"
-mode = "compile"
-hint = """
-Vectors in rust make use of generics to create dynamically sized arrays of any type.
-You need to tell the compiler what type we are pushing onto this vector."""
-
-[[exercises]]
-name = "generics2"
-path = "exercises/generics/generics2.rs"
-mode = "test"
-hint = """
-Currently we are wrapping only values of type 'u32'.
-Maybe we could update the explicit references to this data type somehow?
-
-If you are still stuck https://doc.rust-lang.org/stable/book/ch10-01-syntax.html#in-method-definitions
-"""
-
-[[exercises]]
-name = "generics3"
-path = "exercises/generics/generics3.rs"
-mode = "test"
-hint = """
-To find the best solution to this challenge you're going to need to think back to your
-knowledge of traits, specifically Trait Bound Syntax - you may also need this: "use std::fmt::Display;"
-
-This is definitely harder than the last two exercises! You need to think about not only making the
-ReportCard struct generic, but also the correct property - you will need to change the implementation
-of the struct slightly too...you can do it!
-"""
-
-# THREADS
-
-[[exercises]]
-name = "threads1"
-path = "exercises/threads/threads1.rs"
-mode = "compile"
-hint = """
-`Arc` is an Atomic Reference Counted pointer that allows safe, shared access
-to **immutable** data. But we want to *change* the number of `jobs_completed`
-so we'll need to also use another type that will only allow one thread to
-mutate the data at a time. Take a look at this section of the book:
-https://doc.rust-lang.org/book/ch16-03-shared-state.html#atomic-reference-counting-with-arct
-and keep reading if you'd like more hints :)
-
-
-Do you now have an `Arc` `Mutex` `JobStatus` at the beginning of main? Like:
-`let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));`
-Similar to the code in the example in the book that happens after the text
-that says "We can use Arc to fix this.". If not, give that a try! If you
-do and would like more hints, keep reading!!
-
-
-Make sure neither of your threads are holding onto the lock of the mutex
-while they are sleeping, since this will prevent the other thread from
-being allowed to get the lock. Locks are automatically released when
-they go out of scope.
-
-Ok, so, real talk, this was actually tricky for *me* to do too. And
-I could see a lot of different problems you might run into, so at this
-point I'm not sure which one you've hit :)
-
-Please open an issue if you're still running into a problem that
-these hints are not helping you with, or if you've looked at the sample
-answers and don't understand why they work and yours doesn't.
-
-If you've learned from the sample solutions, I encourage you to come
-back to this exercise and try it again in a few days to reinforce
-what you've learned :)"""
+name = "clippy3"
+path = "exercises/clippy/clippy3.rs"
+mode = "clippy"
+hint = "No hints this time!"
# TYPE CONVERSIONS
[[exercises]]
name = "using_as"
path = "exercises/conversions/using_as.rs"
-mode = "compile"
+mode = "test"
hint = """
Use the `as` operator to cast one of the operands in the last line of the
`average` function into the expected return type."""
@@ -799,26 +1130,52 @@ mode = "test"
hint = """
Follow the steps provided right before the `From` implementation"""
+[[exercises]]
+name = "from_str"
+path = "exercises/conversions/from_str.rs"
+mode = "test"
+hint = """
+The implementation of FromStr should return an Ok with a Person object,
+or an Err with an error if the string is not valid.
+
+This is almost like the `from_into` exercise, but returning errors instead
+of falling back to a default value.
+
+Look at the test cases to see which error variants to return.
+
+Another hint: You can use the `map_err` method of `Result` with a function
+or a closure to wrap the error from `parse::`.
+
+Yet another hint: If you would like to propagate errors by using the `?`
+operator in your solution, you might want to look at
+https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reenter_question_mark.html
+"""
+
[[exercises]]
name = "try_from_into"
path = "exercises/conversions/try_from_into.rs"
mode = "test"
hint = """
Follow the steps provided right before the `TryFrom` implementation.
-You can also use the example at https://doc.rust-lang.org/std/convert/trait.TryFrom.html"""
+You can also use the example at https://doc.rust-lang.org/std/convert/trait.TryFrom.html
+
+Is there an implementation of `TryFrom` in the standard library that
+can both do the required integer conversion and check the range of the input?
+
+Another hint: Look at the test cases to see which error variants to return.
+
+Yet another hint: You can use the `map_err` or `or` methods of `Result` to
+convert errors.
+
+Yet another hint: If you would like to propagate errors by using the `?`
+operator in your solution, you might want to look at
+https://doc.rust-lang.org/stable/rust-by-example/error/multiple_error_types/reenter_question_mark.html
+
+Challenge: Can you make the `TryFrom` implementations generic over many integer types?"""
[[exercises]]
name = "as_ref_mut"
path = "exercises/conversions/as_ref_mut.rs"
mode = "test"
hint = """
-Add AsRef as a trait bound to the functions."""
-
-[[exercises]]
-name = "from_str"
-path = "exercises/conversions/from_str.rs"
-mode = "test"
-hint = """
-The implementation of FromStr should return an Ok with a Person object,
-or an Err with a string if the string is not valid.
-This is almost like the `try_from_into` exercise."""
+Add AsRef or AsMut as a trait bound to the functions."""
diff --git a/install.ps1 b/install.ps1
index 6504e69e..7bab21f6 100644
--- a/install.ps1
+++ b/install.ps1
@@ -1,7 +1,7 @@
#!/usr/bin/env pwsh
#Requires -Version 5
-param($path = "$pwd/rustlings")
+param($path = "$home/rustlings")
Write-Host "Let's get you set up with Rustlings!"
@@ -35,7 +35,7 @@ if (Get-Command cargo -ErrorAction SilentlyContinue) {
function vercomp($v1, $v2) {
if ($v1 -eq $v2) {
return 0
- }
+ }
$v1 = $v1.Replace(".", "0")
$v2 = $v2.Replace(".", "0")
@@ -53,7 +53,7 @@ function vercomp($v1, $v2) {
}
$rustVersion = $(rustc --version).Split(" ")[1]
-$minRustVersion = "1.31"
+$minRustVersion = "1.56"
if ((vercomp $rustVersion $minRustVersion) -eq 2) {
Write-Host "WARNING: Rust version is too old: $rustVersion - needs at least $minRustVersion"
Write-Host "Please update Rust with 'rustup update'"
@@ -91,4 +91,4 @@ if (!$clippy) {
rustup component add clippy
}
-Write-Host "All done! Run 'rustlings' to get started."
+Write-Host "All done! Navigate to $path and run 'rustlings' to get started!"
diff --git a/install.sh b/install.sh
index c32f5126..4ee56bb1 100755
--- a/install.sh
+++ b/install.sh
@@ -1,4 +1,5 @@
#!/usr/bin/env bash
+set -euo pipefail
echo "Let's get you set up with Rustlings!"
@@ -12,12 +13,33 @@ else
exit 1
fi
+if [ -x "$(command -v cc)" ]
+then
+ echo "SUCCESS: cc is installed"
+else
+ echo "ERROR: cc does not seem to be installed."
+ echo "Please download (g)cc using your package manager."
+ echo "OSX: xcode-select --install"
+ echo "Deb: sudo apt install gcc"
+ echo "Yum: sudo yum -y install gcc"
+ exit 1
+fi
+
+if [ -x "$(command -v rustup)" ]
+then
+ echo "SUCCESS: rustup is installed"
+else
+ echo "ERROR: rustup does not seem to be installed."
+ echo "Please download rustup using https://rustup.rs!"
+ exit 1
+fi
+
if [ -x "$(command -v rustc)" ]
then
echo "SUCCESS: Rust is installed"
else
echo "ERROR: Rust does not seem to be installed."
- echo "Please download Rust using https://rustup.rs!"
+ echo "Please download Rust using rustup!"
exit 1
fi
@@ -26,7 +48,7 @@ then
echo "SUCCESS: Cargo is installed"
else
echo "ERROR: Cargo does not seem to be installed."
- echo "Please download Rust and Cargo using https://rustup.rs!"
+ echo "Please download Rust and Cargo using rustup!"
exit 1
fi
@@ -62,7 +84,22 @@ function vercomp() {
then
max_len=$len2
fi
- for i in `seq 0 $max_len`
+
+ #pad right in short arr
+ if [[ len1 -gt len2 ]];
+ then
+ for ((i = len2; i < len1; i++));
+ do
+ v2[$i]=0
+ done
+ else
+ for ((i = len1; i < len2; i++));
+ do
+ v1[$i]=0
+ done
+ fi
+
+ for i in `seq 0 $((max_len-1))`
do
# Fill empty fields with zeros in v1
if [ -z "${v1[$i]}" ]
@@ -87,9 +124,9 @@ function vercomp() {
}
RustVersion=$(rustc --version | cut -d " " -f 2)
-MinRustVersion=1.31
-vercomp $RustVersion $MinRustVersion
-if [ $? -eq 2 ]
+MinRustVersion=1.58
+vercomp "$RustVersion" $MinRustVersion || ec=$?
+if [ ${ec:-0} -eq 2 ]
then
echo "ERROR: Rust version is too old: $RustVersion - needs at least $MinRustVersion"
echo "Please update Rust with 'rustup update'"
@@ -100,11 +137,11 @@ fi
Path=${1:-rustlings/}
echo "Cloning Rustlings at $Path..."
-git clone -q https://github.com/rust-lang/rustlings $Path
+git clone -q https://github.com/rust-lang/rustlings "$Path"
-cd $Path
+cd "$Path"
-Version=$(curl -s https://api.github.com/repos/rust-lang/rustlings/releases/latest | ${PY} -c "import json,sys;obj=json.load(sys.stdin);print(obj['tag_name']);")
+Version=$(curl -s https://api.github.com/repos/rust-lang/rustlings/releases/latest | ${PY} -c "import json,sys;obj=json.load(sys.stdin);print(obj['tag_name']) if 'tag_name' in obj else sys.exit(f\"Error: {obj['message']}\");")
CargoBin="${CARGO_HOME:-$HOME/.cargo}/bin"
if [[ -z ${Version} ]]
@@ -115,8 +152,8 @@ then
if [[ -z ${Version} ]]
then
echo "No valid tag version found"
- echo "Rustlings will be installed using the master branch"
- Version="master"
+ echo "Rustlings will be installed using the main branch"
+ Version="main"
else
Version="tags/${Version}"
fi
diff --git a/oranda.json b/oranda.json
new file mode 100644
index 00000000..603e474e
--- /dev/null
+++ b/oranda.json
@@ -0,0 +1,25 @@
+{
+ "project": {
+ "homepage": "https://rustlings.cool",
+ "repository": "https://github.com/rust-lang/rustlings"
+ },
+ "marketing": {
+ "analytics": {
+ "plausible": {
+ "domain": "rustlings.cool"
+ }
+ }
+ },
+ "components": {
+ "artifacts": {
+ "cargo_dist": false,
+ "package_managers": {
+ "preferred": {
+ "macos/linux/unix": "curl -L https://raw.githubusercontent.com/rust-lang/rustlings/main/install.sh | bash",
+ "windows": "Start-BitsTransfer -Source https://raw.githubusercontent.com/rust-lang/rustlings/main/install.ps1 -Destination $env:TMP/install_rustlings.ps1; Unblock-File $env:TMP/install_rustlings.ps1; Invoke-Expression $env:TMP/install_rustlings.ps1"
+ }
+ }
+ },
+ "changelog": true
+ }
+}
diff --git a/shell.nix b/shell.nix
new file mode 100644
index 00000000..fa2a56c7
--- /dev/null
+++ b/shell.nix
@@ -0,0 +1,6 @@
+(import (let lock = builtins.fromJSON (builtins.readFile ./flake.lock);
+in fetchTarball {
+ url =
+ "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
+ sha256 = lock.nodes.flake-compat.locked.narHash;
+}) { src = ./.; }).shellNix
diff --git a/src/exercise.rs b/src/exercise.rs
index 177b7f38..2cde4e15 100644
--- a/src/exercise.rs
+++ b/src/exercise.rs
@@ -1,5 +1,6 @@
use regex::Regex;
use serde::Deserialize;
+use std::env;
use std::fmt::{self, Display, Formatter};
use std::fs::{self, remove_file, File};
use std::io::Read;
@@ -7,18 +8,24 @@ use std::path::PathBuf;
use std::process::{self, Command};
const RUSTC_COLOR_ARGS: &[&str] = &["--color", "always"];
+const RUSTC_EDITION_ARGS: &[&str] = &["--edition", "2021"];
const I_AM_DONE_REGEX: &str = r"(?m)^\s*///?\s*I\s+AM\s+NOT\s+DONE";
const CONTEXT: usize = 2;
const CLIPPY_CARGO_TOML_PATH: &str = "./exercises/clippy/Cargo.toml";
-// Get a temporary file name that is hopefully unique to this process
+// Get a temporary file name that is hopefully unique
#[inline]
fn temp_file() -> String {
- format!("./temp_{}", process::id())
+ let thread_id: String = format!("{:?}", std::thread::current().id())
+ .chars()
+ .filter(|c| c.is_alphanumeric())
+ .collect();
+
+ format!("./temp_{}_{thread_id}", process::id())
}
// The mode of the exercise.
-#[derive(Deserialize, Copy, Clone)]
+#[derive(Deserialize, Copy, Clone, Debug)]
#[serde(rename_all = "lowercase")]
pub enum Mode {
// Indicates that the exercise should be compiled as a binary
@@ -36,7 +43,7 @@ pub struct ExerciseList {
// A representation of a rustlings exercise.
// This is deserialized from the accompanying info.toml file
-#[derive(Deserialize)]
+#[derive(Deserialize, Debug)]
pub struct Exercise {
// Name of the exercise
pub name: String,
@@ -105,36 +112,43 @@ impl Exercise {
Mode::Compile => Command::new("rustc")
.args(&[self.path.to_str().unwrap(), "-o", &temp_file()])
.args(RUSTC_COLOR_ARGS)
+ .args(RUSTC_EDITION_ARGS)
.output(),
Mode::Test => Command::new("rustc")
.args(&["--test", self.path.to_str().unwrap(), "-o", &temp_file()])
.args(RUSTC_COLOR_ARGS)
+ .args(RUSTC_EDITION_ARGS)
.output(),
Mode::Clippy => {
let cargo_toml = format!(
r#"[package]
name = "{}"
version = "0.0.1"
-edition = "2018"
+edition = "2021"
[[bin]]
name = "{}"
path = "{}.rs""#,
self.name, self.name, self.name
);
- fs::write(CLIPPY_CARGO_TOML_PATH, cargo_toml)
- .expect("Failed to write 📎 Clippy 📎 Cargo.toml file.");
- // To support the ability to run the clipy exercises, build
+ let cargo_toml_error_msg = if env::var("NO_EMOJI").is_ok() {
+ "Failed to write Clippy Cargo.toml file."
+ } else {
+ "Failed to write 📎 Clippy 📎 Cargo.toml file."
+ };
+ fs::write(CLIPPY_CARGO_TOML_PATH, cargo_toml).expect(cargo_toml_error_msg);
+ // To support the ability to run the clippy exercises, build
// an executable, in addition to running clippy. With a
// compilation failure, this would silently fail. But we expect
// clippy to reflect the same failure while compiling later.
Command::new("rustc")
.args(&[self.path.to_str().unwrap(), "-o", &temp_file()])
.args(RUSTC_COLOR_ARGS)
+ .args(RUSTC_EDITION_ARGS)
.output()
.expect("Failed to compile!");
// Due to an issue with Clippy, a cargo clean is required to catch all lints.
// See https://github.com/rust-lang/rust-clippy/issues/2604
- // This is already fixed on master branch. See this issue to track merging into Cargo:
+ // This is already fixed on Clippy's master branch. See this issue to track merging into Cargo:
// https://github.com/rust-lang/rust-clippy/issues/3837
Command::new("cargo")
.args(&["clean", "--manifest-path", CLIPPY_CARGO_TOML_PATH])
@@ -144,7 +158,7 @@ path = "{}.rs""#,
Command::new("cargo")
.args(&["clippy", "--manifest-path", CLIPPY_CARGO_TOML_PATH])
.args(RUSTC_COLOR_ARGS)
- .args(&["--", "-D", "warnings"])
+ .args(&["--", "-D", "warnings", "-D", "clippy::float_cmp"])
.output()
}
}
@@ -152,7 +166,7 @@ path = "{}.rs""#,
if cmd.status.success() {
Ok(CompiledExercise {
- exercise: &self,
+ exercise: self,
_handle: FileHandle,
})
} else {
@@ -167,9 +181,10 @@ path = "{}.rs""#,
fn run(&self) -> Result {
let arg = match self.mode {
Mode::Test => "--show-output",
- _ => ""
+ _ => "",
};
- let cmd = Command::new(&temp_file()).arg(arg)
+ let cmd = Command::new(&temp_file())
+ .arg(arg)
.output()
.expect("Failed to run 'run' command");
@@ -206,8 +221,7 @@ path = "{}.rs""#,
let matched_line_index = source
.lines()
.enumerate()
- .filter_map(|(i, line)| if re.is_match(line) { Some(i) } else { None })
- .next()
+ .find_map(|(i, line)| if re.is_match(line) { Some(i) } else { None })
.expect("This should not happen at all");
let min_line = ((matched_line_index as i32) - (CONTEXT as i32)).max(0) as usize;
@@ -226,6 +240,16 @@ path = "{}.rs""#,
State::Pending(context)
}
+
+ // Check that the exercise looks to be solved using self.state()
+ // This is not the best way to check since
+ // the user can just remove the "I AM NOT DONE" string from the file
+ // without actually having solved anything.
+ // The only other way to truly check this would to compile and run
+ // the exercise; which would be both costly and counterintuitive
+ pub fn looks_done(&self) -> bool {
+ self.state() == State::Done
+ }
}
impl Display for Exercise {
@@ -314,7 +338,7 @@ mod test {
#[test]
fn test_exercise_with_output() {
let exercise = Exercise {
- name: "finished_exercise".into(),
+ name: "exercise_with_output".into(),
path: PathBuf::from("tests/fixture/success/testSuccess.rs"),
mode: Mode::Test,
hint: String::new(),
diff --git a/src/main.rs b/src/main.rs
index 9c64de2b..0a9af2ec 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,16 +1,18 @@
use crate::exercise::{Exercise, ExerciseList};
-use crate::run::run;
+use crate::project::RustAnalyzerProject;
+use crate::run::{reset, run};
use crate::verify::verify;
-use clap::{crate_version, App, Arg, SubCommand};
+use argh::FromArgs;
use console::Emoji;
use notify::DebouncedEvent;
use notify::{RecommendedWatcher, RecursiveMode, Watcher};
use std::ffi::OsStr;
use std::fs;
-use std::io;
+use std::io::{self, prelude::*};
use std::path::Path;
use std::process::{Command, Stdio};
-use std::sync::mpsc::channel;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{channel, RecvTimeoutError};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
@@ -19,53 +21,116 @@ use std::time::Duration;
mod ui;
mod exercise;
+mod project;
mod run;
mod verify;
-fn main() {
- let matches = App::new("rustlings")
- .version(crate_version!())
- .author("Olivia Hugger, Carol Nichols")
- .about("Rustlings is a collection of small exercises to get you used to writing and reading Rust code")
- .arg(
- Arg::with_name("nocapture")
- .long("nocapture")
- .help("Show outputs from the test exercises")
- )
- .subcommand(
- SubCommand::with_name("verify")
- .alias("v")
- .about("Verifies all exercises according to the recommended order")
- )
- .subcommand(
- SubCommand::with_name("watch")
- .alias("w")
- .about("Reruns `verify` when files were edited")
- )
- .subcommand(
- SubCommand::with_name("run")
- .alias("r")
- .about("Runs/Tests a single exercise")
- .arg(Arg::with_name("name").required(true).index(1)),
- )
- .subcommand(
- SubCommand::with_name("hint")
- .alias("h")
- .about("Returns a hint for the current exercise")
- .arg(Arg::with_name("name").required(true).index(1)),
- )
- .get_matches();
+// In sync with crate version
+const VERSION: &str = "5.5.1";
- if matches.subcommand_name().is_none() {
- println!();
- println!(r#" welcome to... "#);
- println!(r#" _ _ _ "#);
- println!(r#" _ __ _ _ ___| |_| (_)_ __ __ _ ___ "#);
- println!(r#" | '__| | | / __| __| | | '_ \ / _` / __| "#);
- println!(r#" | | | |_| \__ \ |_| | | | | | (_| \__ \ "#);
- println!(r#" |_| \__,_|___/\__|_|_|_| |_|\__, |___/ "#);
- println!(r#" |___/ "#);
- println!();
+#[derive(FromArgs, PartialEq, Debug)]
+/// Rustlings is a collection of small exercises to get you used to writing and reading Rust code
+struct Args {
+ /// show outputs from the test exercises
+ #[argh(switch)]
+ nocapture: bool,
+ /// show the executable version
+ #[argh(switch, short = 'v')]
+ version: bool,
+ #[argh(subcommand)]
+ nested: Option,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand)]
+enum Subcommands {
+ Verify(VerifyArgs),
+ Watch(WatchArgs),
+ Run(RunArgs),
+ Reset(ResetArgs),
+ Hint(HintArgs),
+ List(ListArgs),
+ Lsp(LspArgs),
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "verify")]
+/// Verifies all exercises according to the recommended order
+struct VerifyArgs {}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "watch")]
+/// Reruns `verify` when files were edited
+struct WatchArgs {
+ /// show hints on success
+ #[argh(switch)]
+ success_hints: bool,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "run")]
+/// Runs/Tests a single exercise
+struct RunArgs {
+ #[argh(positional)]
+ /// the name of the exercise
+ name: String,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "reset")]
+/// Resets a single exercise using "git stash -- "
+struct ResetArgs {
+ #[argh(positional)]
+ /// the name of the exercise
+ name: String,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "hint")]
+/// Returns a hint for the given exercise
+struct HintArgs {
+ #[argh(positional)]
+ /// the name of the exercise
+ name: String,
+}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "lsp")]
+/// Enable rust-analyzer for exercises
+struct LspArgs {}
+
+#[derive(FromArgs, PartialEq, Debug)]
+#[argh(subcommand, name = "list")]
+/// Lists the exercises available in Rustlings
+struct ListArgs {
+ #[argh(switch, short = 'p')]
+ /// show only the paths of the exercises
+ paths: bool,
+ #[argh(switch, short = 'n')]
+ /// show only the names of the exercises
+ names: bool,
+ #[argh(option, short = 'f')]
+ /// provide a string to match exercise names
+ /// comma separated patterns are acceptable
+ filter: Option,
+ #[argh(switch, short = 'u')]
+ /// display only exercises not yet solved
+ unsolved: bool,
+ #[argh(switch, short = 's')]
+ /// display only exercises that have been solved
+ solved: bool,
+}
+
+fn main() {
+ let args: Args = argh::from_env();
+
+ if args.version {
+ println!("v{VERSION}");
+ std::process::exit(0);
+ }
+
+ if args.nested.is_none() {
+ println!("\n{WELCOME}\n");
}
if !Path::new("info.toml").exists() {
@@ -86,82 +151,212 @@ fn main() {
let toml_str = &fs::read_to_string("info.toml").unwrap();
let exercises = toml::from_str::(toml_str).unwrap().exercises;
- let verbose = matches.is_present("nocapture");
+ let verbose = args.nocapture;
- if let Some(ref matches) = matches.subcommand_matches("run") {
- let name = matches.value_of("name").unwrap();
-
- let matching_exercise = |e: &&Exercise| name == e.name;
-
- let exercise = exercises.iter().find(matching_exercise).unwrap_or_else(|| {
- println!("No exercise found for your given name!");
- std::process::exit(1)
- });
-
- run(&exercise, verbose).unwrap_or_else(|_| std::process::exit(1));
- }
-
- if let Some(ref matches) = matches.subcommand_matches("hint") {
- let name = matches.value_of("name").unwrap();
-
- let exercise = exercises
- .iter()
- .find(|e| name == e.name)
- .unwrap_or_else(|| {
- println!("No exercise found for your given name!");
- std::process::exit(1)
+ let command = args.nested.unwrap_or_else(|| {
+ println!("{DEFAULT_OUT}\n");
+ std::process::exit(0);
+ });
+ match command {
+ Subcommands::List(subargs) => {
+ if !subargs.paths && !subargs.names {
+ println!("{:<17}\t{:<46}\t{:<7}", "Name", "Path", "Status");
+ }
+ let mut exercises_done: u16 = 0;
+ let filters = subargs.filter.clone().unwrap_or_default().to_lowercase();
+ exercises.iter().for_each(|e| {
+ let fname = format!("{}", e.path.display());
+ let filter_cond = filters
+ .split(',')
+ .filter(|f| !f.trim().is_empty())
+ .any(|f| e.name.contains(&f) || fname.contains(&f));
+ let status = if e.looks_done() {
+ exercises_done += 1;
+ "Done"
+ } else {
+ "Pending"
+ };
+ let solve_cond = {
+ (e.looks_done() && subargs.solved)
+ || (!e.looks_done() && subargs.unsolved)
+ || (!subargs.solved && !subargs.unsolved)
+ };
+ if solve_cond && (filter_cond || subargs.filter.is_none()) {
+ let line = if subargs.paths {
+ format!("{fname}\n")
+ } else if subargs.names {
+ format!("{}\n", e.name)
+ } else {
+ format!("{:<17}\t{fname:<46}\t{status:<7}\n", e.name)
+ };
+ // Somehow using println! leads to the binary panicking
+ // when its output is piped.
+ // So, we're handling a Broken Pipe error and exiting with 0 anyway
+ let stdout = std::io::stdout();
+ {
+ let mut handle = stdout.lock();
+ handle.write_all(line.as_bytes()).unwrap_or_else(|e| {
+ match e.kind() {
+ std::io::ErrorKind::BrokenPipe => std::process::exit(0),
+ _ => std::process::exit(1),
+ };
+ });
+ }
+ }
});
+ let percentage_progress = exercises_done as f32 / exercises.len() as f32 * 100.0;
+ println!(
+ "Progress: You completed {} / {} exercises ({:.1} %).",
+ exercises_done,
+ exercises.len(),
+ percentage_progress
+ );
+ std::process::exit(0);
+ }
- println!("{}", exercise.hint);
- }
+ Subcommands::Run(subargs) => {
+ let exercise = find_exercise(&subargs.name, &exercises);
- if matches.subcommand_matches("verify").is_some() {
- verify(&exercises, verbose).unwrap_or_else(|_| std::process::exit(1));
- }
+ run(exercise, verbose).unwrap_or_else(|_| std::process::exit(1));
+ }
- if matches.subcommand_matches("watch").is_some() && watch(&exercises, verbose).is_ok() {
- println!(
- "{emoji} All exercises completed! {emoji}",
- emoji = Emoji("🎉", "★")
- );
- println!();
- println!("We hope you enjoyed learning about the various aspects of Rust!");
- println!(
- "If you noticed any issues, please don't hesitate to report them to our repo."
- );
- println!("You can also contribute your own exercises to help the greater community!");
- println!();
- println!("Before reporting an issue or contributing, please read our guidelines:");
- println!("https://github.com/rust-lang/rustlings/blob/master/CONTRIBUTING.md");
- }
+ Subcommands::Reset(subargs) => {
+ let exercise = find_exercise(&subargs.name, &exercises);
- if matches.subcommand_name().is_none() {
- let text = fs::read_to_string("default_out.txt").unwrap();
- println!("{}", text);
+ reset(exercise).unwrap_or_else(|_| std::process::exit(1));
+ }
+
+ Subcommands::Hint(subargs) => {
+ let exercise = find_exercise(&subargs.name, &exercises);
+
+ println!("{}", exercise.hint);
+ }
+
+ Subcommands::Verify(_subargs) => {
+ verify(&exercises, (0, exercises.len()), verbose, false)
+ .unwrap_or_else(|_| std::process::exit(1));
+ }
+
+ Subcommands::Lsp(_subargs) => {
+ let mut project = RustAnalyzerProject::new();
+ project
+ .get_sysroot_src()
+ .expect("Couldn't find toolchain path, do you have `rustc` installed?");
+ project
+ .exercises_to_json()
+ .expect("Couldn't parse rustlings exercises files");
+
+ if project.crates.is_empty() {
+ println!("Failed find any exercises, make sure you're in the `rustlings` folder");
+ } else if project.write_to_disk().is_err() {
+ println!("Failed to write rust-project.json to disk for rust-analyzer");
+ } else {
+ println!("Successfully generated rust-project.json");
+ println!("rust-analyzer will now parse exercises, restart your language server or editor")
+ }
+ }
+
+ Subcommands::Watch(_subargs) => match watch(&exercises, verbose, _subargs.success_hints) {
+ Err(e) => {
+ println!(
+ "Error: Could not watch your progress. Error message was {:?}.",
+ e
+ );
+ println!("Most likely you've run out of disk space or your 'inotify limit' has been reached.");
+ std::process::exit(1);
+ }
+ Ok(WatchStatus::Finished) => {
+ println!(
+ "{emoji} All exercises completed! {emoji}",
+ emoji = Emoji("🎉", "★")
+ );
+ println!("\n{FENISH_LINE}\n");
+ }
+ Ok(WatchStatus::Unfinished) => {
+ println!("We hope you're enjoying learning about Rust!");
+ println!("If you want to continue working on the exercises at a later point, you can simply run `rustlings watch` again");
+ }
+ },
}
}
-fn spawn_watch_shell(failed_exercise_hint: &Arc>>) {
+fn spawn_watch_shell(
+ failed_exercise_hint: &Arc>>,
+ should_quit: Arc,
+) {
let failed_exercise_hint = Arc::clone(failed_exercise_hint);
- println!("Type 'hint' to get help");
+ println!("Welcome to watch mode! You can type 'help' to get an overview of the commands you can use here.");
thread::spawn(move || loop {
let mut input = String::new();
match io::stdin().read_line(&mut input) {
Ok(_) => {
- if input.trim().eq("hint") {
+ let input = input.trim();
+ if input == "hint" {
if let Some(hint) = &*failed_exercise_hint.lock().unwrap() {
- println!("{}", hint);
+ println!("{hint}");
+ }
+ } else if input == "clear" {
+ println!("\x1B[2J\x1B[1;1H");
+ } else if input.eq("quit") {
+ should_quit.store(true, Ordering::SeqCst);
+ println!("Bye!");
+ } else if input.eq("help") {
+ println!("Commands available to you in watch mode:");
+ println!(" hint - prints the current exercise's hint");
+ println!(" clear - clears the screen");
+ println!(" quit - quits watch mode");
+ println!(" ! - executes a command, like `!rustc --explain E0381`");
+ println!(" help - displays this help message");
+ println!();
+ println!("Watch mode automatically re-evaluates the current exercise");
+ println!("when you edit a file's contents.")
+ } else if let Some(cmd) = input.strip_prefix('!') {
+ let parts: Vec<&str> = cmd.split_whitespace().collect();
+ if parts.is_empty() {
+ println!("no command provided");
+ } else if let Err(e) = Command::new(parts[0]).args(&parts[1..]).status() {
+ println!("failed to execute command `{}`: {}", cmd, e);
}
} else {
- println!("unknown command: {}", input);
+ println!("unknown command: {input}");
}
}
- Err(error) => println!("error reading command: {}", error),
+ Err(error) => println!("error reading command: {error}"),
}
});
}
-fn watch(exercises: &[Exercise], verbose: bool) -> notify::Result<()> {
+fn find_exercise<'a>(name: &str, exercises: &'a [Exercise]) -> &'a Exercise {
+ if name.eq("next") {
+ exercises
+ .iter()
+ .find(|e| !e.looks_done())
+ .unwrap_or_else(|| {
+ println!("🎉 Congratulations! You have done all the exercises!");
+ println!("🔚 There are no more exercises to do next!");
+ std::process::exit(1)
+ })
+ } else {
+ exercises
+ .iter()
+ .find(|e| e.name == name)
+ .unwrap_or_else(|| {
+ println!("No exercise found for '{name}'!");
+ std::process::exit(1)
+ })
+ }
+}
+
+enum WatchStatus {
+ Finished,
+ Unfinished,
+}
+
+fn watch(
+ exercises: &[Exercise],
+ verbose: bool,
+ success_hints: bool,
+) -> notify::Result {
/* Clears the terminal with an ANSI escape code.
Works in UNIX and newer Windows terminals. */
fn clear_screen() {
@@ -169,30 +364,48 @@ fn watch(exercises: &[Exercise], verbose: bool) -> notify::Result<()> {
}
let (tx, rx) = channel();
+ let should_quit = Arc::new(AtomicBool::new(false));
- let mut watcher: RecommendedWatcher = Watcher::new(tx, Duration::from_secs(2))?;
+ let mut watcher: RecommendedWatcher = Watcher::new(tx, Duration::from_secs(1))?;
watcher.watch(Path::new("./exercises"), RecursiveMode::Recursive)?;
clear_screen();
let to_owned_hint = |t: &Exercise| t.hint.to_owned();
- let failed_exercise_hint = match verify(exercises.iter(), verbose) {
- Ok(_) => return Ok(()),
+ let failed_exercise_hint = match verify(
+ exercises.iter(),
+ (0, exercises.len()),
+ verbose,
+ success_hints,
+ ) {
+ Ok(_) => return Ok(WatchStatus::Finished),
Err(exercise) => Arc::new(Mutex::new(Some(to_owned_hint(exercise)))),
};
- spawn_watch_shell(&failed_exercise_hint);
+ spawn_watch_shell(&failed_exercise_hint, Arc::clone(&should_quit));
loop {
- match rx.recv() {
+ match rx.recv_timeout(Duration::from_secs(1)) {
Ok(event) => match event {
DebouncedEvent::Create(b) | DebouncedEvent::Chmod(b) | DebouncedEvent::Write(b) => {
if b.extension() == Some(OsStr::new("rs")) && b.exists() {
let filepath = b.as_path().canonicalize().unwrap();
let pending_exercises = exercises
.iter()
- .skip_while(|e| !filepath.ends_with(&e.path));
+ .find(|e| filepath.ends_with(&e.path))
+ .into_iter()
+ .chain(
+ exercises
+ .iter()
+ .filter(|e| !e.looks_done() && !filepath.ends_with(&e.path)),
+ );
+ let num_done = exercises.iter().filter(|e| e.looks_done()).count();
clear_screen();
- match verify(pending_exercises, verbose) {
- Ok(_) => return Ok(()),
+ match verify(
+ pending_exercises,
+ (num_done, exercises.len()),
+ verbose,
+ success_hints,
+ ) {
+ Ok(_) => return Ok(WatchStatus::Finished),
Err(exercise) => {
let mut failed_exercise_hint = failed_exercise_hint.lock().unwrap();
*failed_exercise_hint = Some(to_owned_hint(exercise));
@@ -202,7 +415,14 @@ fn watch(exercises: &[Exercise], verbose: bool) -> notify::Result<()> {
}
_ => {}
},
- Err(e) => println!("watch error: {:?}", e),
+ Err(RecvTimeoutError::Timeout) => {
+ // the timeout expired, just check the `should_quit` variable below then loop again
+ }
+ Err(e) => println!("watch error: {e:?}"),
+ }
+ // Check if we need to exit
+ if should_quit.load(Ordering::SeqCst) {
+ return Ok(WatchStatus::Unfinished);
}
}
}
@@ -216,3 +436,66 @@ fn rustc_exists() -> bool {
.map(|status| status.success())
.unwrap_or(false)
}
+
+const DEFAULT_OUT: &str = r#"Thanks for installing Rustlings!
+
+Is this your first time? Don't worry, Rustlings was made for beginners! We are
+going to teach you a lot of things about Rust, but before we can get
+started, here's a couple of notes about how Rustlings operates:
+
+1. The central concept behind Rustlings is that you solve exercises. These
+ exercises usually have some sort of syntax error in them, which will cause
+ them to fail compilation or testing. Sometimes there's a logic error instead
+ of a syntax error. No matter what error, it's your job to find it and fix it!
+ You'll know when you fixed it because then, the exercise will compile and
+ Rustlings will be able to move on to the next exercise.
+2. If you run Rustlings in watch mode (which we recommend), it'll automatically
+ start with the first exercise. Don't get confused by an error message popping
+ up as soon as you run Rustlings! This is part of the exercise that you're
+ supposed to solve, so open the exercise file in an editor and start your
+ detective work!
+3. If you're stuck on an exercise, there is a helpful hint you can view by typing
+ 'hint' (in watch mode), or running `rustlings hint exercise_name`.
+4. If an exercise doesn't make sense to you, feel free to open an issue on GitHub!
+ (https://github.com/rust-lang/rustlings/issues/new). We look at every issue,
+ and sometimes, other learners do too so you can help each other out!
+5. If you want to use `rust-analyzer` with exercises, which provides features like
+ autocompletion, run the command `rustlings lsp`.
+
+Got all that? Great! To get started, run `rustlings watch` in order to get the first
+exercise. Make sure to have your editor open!"#;
+
+const FENISH_LINE: &str = r#"+----------------------------------------------------+
+| You made it to the Fe-nish line! |
++-------------------------- ------------------------+
+ \\/
+ ▒▒ ▒▒▒▒▒▒▒▒ ▒▒▒▒▒▒▒▒ ▒▒
+ ▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒
+ ▒▒▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒▒▒
+ ░░▒▒▒▒░░▒▒ ▒▒ ▒▒ ▒▒ ▒▒░░▒▒▒▒
+ ▓▓▓▓▓▓▓▓ ▓▓ ▓▓██ ▓▓ ▓▓██ ▓▓ ▓▓▓▓▓▓▓▓
+ ▒▒▒▒ ▒▒ ████ ▒▒ ████ ▒▒░░ ▒▒▒▒
+ ▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒
+ ▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▒▒▒▒▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▒▒
+ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
+ ▒▒▒▒▒▒▒▒▒▒██▒▒▒▒▒▒██▒▒▒▒▒▒▒▒▒▒
+ ▒▒ ▒▒▒▒▒▒▒▒▒▒██████▒▒▒▒▒▒▒▒▒▒ ▒▒
+ ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒
+ ▒▒ ▒▒ ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ▒▒ ▒▒
+ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒ ▒▒
+ ▒▒ ▒▒ ▒▒ ▒▒
+
+We hope you enjoyed learning about the various aspects of Rust!
+If you noticed any issues, please don't hesitate to report them to our repo.
+You can also contribute your own exercises to help the greater community!
+
+Before reporting an issue or contributing, please read our guidelines:
+https://github.com/rust-lang/rustlings/blob/main/CONTRIBUTING.md"#;
+
+const WELCOME: &str = r#" welcome to...
+ _ _ _
+ _ __ _ _ ___| |_| (_)_ __ __ _ ___
+ | '__| | | / __| __| | | '_ \ / _` / __|
+ | | | |_| \__ \ |_| | | | | | (_| \__ \
+ |_| \__,_|___/\__|_|_|_| |_|\__, |___/
+ |___/"#;
diff --git a/src/project.rs b/src/project.rs
new file mode 100644
index 00000000..ebebe27d
--- /dev/null
+++ b/src/project.rs
@@ -0,0 +1,99 @@
+use glob::glob;
+use serde::{Deserialize, Serialize};
+use std::env;
+use std::error::Error;
+use std::path::PathBuf;
+use std::process::Command;
+
+/// Contains the structure of resulting rust-project.json file
+/// and functions to build the data required to create the file
+#[derive(Serialize, Deserialize)]
+pub struct RustAnalyzerProject {
+ sysroot_src: String,
+ pub crates: Vec,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Crate {
+ root_module: String,
+ edition: String,
+ deps: Vec,
+ cfg: Vec,
+}
+
+impl RustAnalyzerProject {
+ pub fn new() -> RustAnalyzerProject {
+ RustAnalyzerProject {
+ sysroot_src: String::new(),
+ crates: Vec::new(),
+ }
+ }
+
+ /// Write rust-project.json to disk
+ pub fn write_to_disk(&self) -> Result<(), std::io::Error> {
+ std::fs::write(
+ "./rust-project.json",
+ serde_json::to_vec(&self).expect("Failed to serialize to JSON"),
+ )?;
+ Ok(())
+ }
+
+ /// If path contains .rs extension, add a crate to `rust-project.json`
+ fn path_to_json(&mut self, path: PathBuf) -> Result<(), Box> {
+ if let Some(ext) = path.extension() {
+ if ext == "rs" {
+ self.crates.push(Crate {
+ root_module: path.display().to_string(),
+ edition: "2021".to_string(),
+ deps: Vec::new(),
+ // This allows rust_analyzer to work inside #[test] blocks
+ cfg: vec!["test".to_string()],
+ })
+ }
+ }
+
+ Ok(())
+ }
+
+ /// Parse the exercises folder for .rs files, any matches will create
+ /// a new `crate` in rust-project.json which allows rust-analyzer to
+ /// treat it like a normal binary
+ pub fn exercises_to_json(&mut self) -> Result<(), Box> {
+ for path in glob("./exercises/**/*")? {
+ self.path_to_json(path?)?;
+ }
+ Ok(())
+ }
+
+ /// Use `rustc` to determine the default toolchain
+ pub fn get_sysroot_src(&mut self) -> Result<(), Box> {
+ // check if RUST_SRC_PATH is set
+ if let Ok(path) = env::var("RUST_SRC_PATH") {
+ self.sysroot_src = path;
+ return Ok(());
+ }
+
+ let toolchain = Command::new("rustc")
+ .arg("--print")
+ .arg("sysroot")
+ .output()?
+ .stdout;
+
+ let toolchain = String::from_utf8_lossy(&toolchain);
+ let mut whitespace_iter = toolchain.split_whitespace();
+
+ let toolchain = whitespace_iter.next().unwrap_or(&toolchain);
+
+ println!("Determined toolchain: {}\n", &toolchain);
+
+ self.sysroot_src = (std::path::Path::new(&*toolchain)
+ .join("lib")
+ .join("rustlib")
+ .join("src")
+ .join("rust")
+ .join("library")
+ .to_string_lossy())
+ .to_string();
+ Ok(())
+ }
+}
diff --git a/src/run.rs b/src/run.rs
index fdabb3e0..1e2e56cf 100644
--- a/src/run.rs
+++ b/src/run.rs
@@ -1,3 +1,5 @@
+use std::process::Command;
+
use crate::exercise::{Exercise, Mode};
use crate::verify::test;
use indicatif::ProgressBar;
@@ -15,12 +17,25 @@ pub fn run(exercise: &Exercise, verbose: bool) -> Result<(), ()> {
Ok(())
}
+// Resets the exercise by stashing the changes.
+pub fn reset(exercise: &Exercise) -> Result<(), ()> {
+ let command = Command::new("git")
+ .args(["stash", "--"])
+ .arg(&exercise.path)
+ .spawn();
+
+ match command {
+ Ok(_) => Ok(()),
+ Err(_) => Err(()),
+ }
+}
+
// Invoke the rust compiler on the path of the given exercise
// and run the ensuing binary.
// This is strictly for non-test binaries, so output is displayed
fn compile_and_run(exercise: &Exercise) -> Result<(), ()> {
let progress_bar = ProgressBar::new_spinner();
- progress_bar.set_message(format!("Compiling {}...", exercise).as_str());
+ progress_bar.set_message(format!("Compiling {exercise}..."));
progress_bar.enable_steady_tick(100);
let compilation_result = exercise.compile();
@@ -37,7 +52,7 @@ fn compile_and_run(exercise: &Exercise) -> Result<(), ()> {
}
};
- progress_bar.set_message(format!("Running {}...", exercise).as_str());
+ progress_bar.set_message(format!("Running {exercise}..."));
let result = compilation.run();
progress_bar.finish_and_clear();
diff --git a/src/ui.rs b/src/ui.rs
index 38cbaa40..1ee46316 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -1,23 +1,33 @@
macro_rules! warn {
($fmt:literal, $ex:expr) => {{
use console::{style, Emoji};
+ use std::env;
let formatstr = format!($fmt, $ex);
- println!(
- "{} {}",
- style(Emoji("⚠️ ", "!")).red(),
- style(formatstr).red()
- );
+ if env::var("NO_EMOJI").is_ok() {
+ println!("{} {}", style("!").red(), style(formatstr).red());
+ } else {
+ println!(
+ "{} {}",
+ style(Emoji("⚠️ ", "!")).red(),
+ style(formatstr).red()
+ );
+ }
}};
}
macro_rules! success {
($fmt:literal, $ex:expr) => {{
use console::{style, Emoji};
+ use std::env;
let formatstr = format!($fmt, $ex);
- println!(
- "{} {}",
- style(Emoji("✅", "✓")).green(),
- style(formatstr).green()
- );
+ if env::var("NO_EMOJI").is_ok() {
+ println!("{} {}", style("✓").green(), style(formatstr).green());
+ } else {
+ println!(
+ "{} {}",
+ style(Emoji("✅", "✓")).green(),
+ style(formatstr).green()
+ );
+ }
}};
}
diff --git a/src/verify.rs b/src/verify.rs
index 807bea9e..f3f3b564 100644
--- a/src/verify.rs
+++ b/src/verify.rs
@@ -1,6 +1,7 @@
use crate::exercise::{CompiledExercise, Exercise, Mode, State};
use console::style;
-use indicatif::ProgressBar;
+use indicatif::{ProgressBar, ProgressStyle};
+use std::env;
// Verify that the provided container of Exercise objects
// can be compiled and run without any failures.
@@ -8,18 +9,33 @@ use indicatif::ProgressBar;
// If the Exercise being verified is a test, the verbose boolean
// determines whether or not the test harness outputs are displayed.
pub fn verify<'a>(
- start_at: impl IntoIterator- ,
- verbose: bool
+ exercises: impl IntoIterator
- ,
+ progress: (usize, usize),
+ verbose: bool,
+ success_hints: bool,
) -> Result<(), &'a Exercise> {
- for exercise in start_at {
+ let (num_done, total) = progress;
+ let bar = ProgressBar::new(total as u64);
+ let mut percentage = num_done as f32 / total as f32 * 100.0;
+ bar.set_style(ProgressStyle::default_bar()
+ .template("Progress: [{bar:60.green/red}] {pos}/{len} {msg}")
+ .progress_chars("#>-")
+ );
+ bar.set_position(num_done as u64);
+ bar.set_message(format!("({:.1} %)", percentage));
+
+ for exercise in exercises {
let compile_result = match exercise.mode {
- Mode::Test => compile_and_test(&exercise, RunMode::Interactive, verbose),
- Mode::Compile => compile_and_run_interactively(&exercise),
- Mode::Clippy => compile_only(&exercise),
+ Mode::Test => compile_and_test(exercise, RunMode::Interactive, verbose, success_hints),
+ Mode::Compile => compile_and_run_interactively(exercise, success_hints),
+ Mode::Clippy => compile_only(exercise, success_hints),
};
if !compile_result.unwrap_or(false) {
return Err(exercise);
}
+ percentage += 100.0 / total as f32;
+ bar.inc(1);
+ bar.set_message(format!("({:.1} %)", percentage));
}
Ok(())
}
@@ -31,32 +47,31 @@ enum RunMode {
// Compile and run the resulting test harness of the given Exercise
pub fn test(exercise: &Exercise, verbose: bool) -> Result<(), ()> {
- compile_and_test(exercise, RunMode::NonInteractive, verbose)?;
+ compile_and_test(exercise, RunMode::NonInteractive, verbose, false)?;
Ok(())
}
// Invoke the rust compiler without running the resulting binary
-fn compile_only(exercise: &Exercise) -> Result {
+fn compile_only(exercise: &Exercise, success_hints: bool) -> Result {
let progress_bar = ProgressBar::new_spinner();
- progress_bar.set_message(format!("Compiling {}...", exercise).as_str());
+ progress_bar.set_message(format!("Compiling {exercise}..."));
progress_bar.enable_steady_tick(100);
- let _ = compile(&exercise, &progress_bar)?;
+ let _ = compile(exercise, &progress_bar)?;
progress_bar.finish_and_clear();
- success!("Successfully compiled {}!", exercise);
- Ok(prompt_for_completion(&exercise, None))
+ Ok(prompt_for_completion(exercise, None, success_hints))
}
// Compile the given Exercise and run the resulting binary in an interactive mode
-fn compile_and_run_interactively(exercise: &Exercise) -> Result {
+fn compile_and_run_interactively(exercise: &Exercise, success_hints: bool) -> Result {
let progress_bar = ProgressBar::new_spinner();
- progress_bar.set_message(format!("Compiling {}...", exercise).as_str());
+ progress_bar.set_message(format!("Compiling {exercise}..."));
progress_bar.enable_steady_tick(100);
- let compilation = compile(&exercise, &progress_bar)?;
+ let compilation = compile(exercise, &progress_bar)?;
- progress_bar.set_message(format!("Running {}...", exercise).as_str());
+ progress_bar.set_message(format!("Running {exercise}..."));
let result = compilation.run();
progress_bar.finish_and_clear();
@@ -70,18 +85,14 @@ fn compile_and_run_interactively(exercise: &Exercise) -> Result {
}
};
- success!("Successfully ran {}!", exercise);
-
- Ok(prompt_for_completion(&exercise, Some(output.stdout)))
+ Ok(prompt_for_completion(exercise, Some(output.stdout), success_hints))
}
// Compile the given Exercise as a test harness and display
// the output if verbose is set to true
-fn compile_and_test(
- exercise: &Exercise, run_mode: RunMode, verbose: bool
-) -> Result {
+fn compile_and_test(exercise: &Exercise, run_mode: RunMode, verbose: bool, success_hints: bool) -> Result {
let progress_bar = ProgressBar::new_spinner();
- progress_bar.set_message(format!("Testing {}...", exercise).as_str());
+ progress_bar.set_message(format!("Testing {exercise}..."));
progress_bar.enable_steady_tick(100);
let compilation = compile(exercise, &progress_bar)?;
@@ -93,9 +104,8 @@ fn compile_and_test(
if verbose {
println!("{}", output.stdout);
}
- success!("Successfully tested {}", &exercise);
if let RunMode::Interactive = run_mode {
- Ok(prompt_for_completion(&exercise, None))
+ Ok(prompt_for_completion(exercise, None, success_hints))
} else {
Ok(true)
}
@@ -133,26 +143,49 @@ fn compile<'a, 'b>(
}
}
-fn prompt_for_completion(exercise: &Exercise, prompt_output: Option) -> bool {
+fn prompt_for_completion(exercise: &Exercise, prompt_output: Option, success_hints: bool) -> bool {
let context = match exercise.state() {
State::Done => return true,
State::Pending(context) => context,
};
+ match exercise.mode {
+ Mode::Compile => success!("Successfully ran {}!", exercise),
+ Mode::Test => success!("Successfully tested {}!", exercise),
+ Mode::Clippy => success!("Successfully compiled {}!", exercise),
+ }
+
+ let no_emoji = env::var("NO_EMOJI").is_ok();
+
+ let clippy_success_msg = if no_emoji {
+ "The code is compiling, and Clippy is happy!"
+ } else {
+ "The code is compiling, and 📎 Clippy 📎 is happy!"
+ };
let success_msg = match exercise.mode {
Mode::Compile => "The code is compiling!",
Mode::Test => "The code is compiling, and the tests pass!",
- Mode::Clippy => "The code is compiling, and 📎 Clippy 📎 is happy!",
+ Mode::Clippy => clippy_success_msg,
};
-
println!();
- println!("🎉 🎉 {} 🎉 🎉", success_msg);
+ if no_emoji {
+ println!("~*~ {success_msg} ~*~")
+ } else {
+ println!("🎉 🎉 {success_msg} 🎉 🎉")
+ }
println!();
if let Some(output) = prompt_output {
println!("Output:");
println!("{}", separator());
- println!("{}", output);
+ println!("{output}");
+ println!("{}", separator());
+ println!();
+ }
+ if success_hints {
+ println!("Hints:");
+ println!("{}", separator());
+ println!("{}", exercise.hint);
println!("{}", separator());
println!();
}
diff --git a/tests/fixture/state/info.toml b/tests/fixture/state/info.toml
index 7bfc697e..547b3a48 100644
--- a/tests/fixture/state/info.toml
+++ b/tests/fixture/state/info.toml
@@ -9,3 +9,10 @@ name = "pending_test_exercise"
path = "pending_test_exercise.rs"
mode = "test"
hint = """"""
+
+[[exercises]]
+name = "finished_exercise"
+path = "finished_exercise.rs"
+mode = "compile"
+hint = """"""
+
diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs
index 0f49b5a8..1a729232 100644
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -24,7 +24,7 @@ fn fails_when_in_wrong_dir() {
fn verify_all_success() {
Command::cargo_bin("rustlings")
.unwrap()
- .arg("v")
+ .arg("verify")
.current_dir("tests/fixture/success")
.assert()
.success();
@@ -34,7 +34,7 @@ fn verify_all_success() {
fn verify_fails_if_some_fails() {
Command::cargo_bin("rustlings")
.unwrap()
- .arg("v")
+ .arg("verify")
.current_dir("tests/fixture/failure")
.assert()
.code(1);
@@ -44,7 +44,7 @@ fn verify_fails_if_some_fails() {
fn run_single_compile_success() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "compSuccess"])
+ .args(&["run", "compSuccess"])
.current_dir("tests/fixture/success/")
.assert()
.success();
@@ -54,7 +54,7 @@ fn run_single_compile_success() {
fn run_single_compile_failure() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "compFailure"])
+ .args(&["run", "compFailure"])
.current_dir("tests/fixture/failure/")
.assert()
.code(1);
@@ -64,7 +64,7 @@ fn run_single_compile_failure() {
fn run_single_test_success() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "testSuccess"])
+ .args(&["run", "testSuccess"])
.current_dir("tests/fixture/success/")
.assert()
.success();
@@ -74,7 +74,7 @@ fn run_single_test_success() {
fn run_single_test_failure() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "testFailure"])
+ .args(&["run", "testFailure"])
.current_dir("tests/fixture/failure/")
.assert()
.code(1);
@@ -84,7 +84,7 @@ fn run_single_test_failure() {
fn run_single_test_not_passed() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "testNotPassed.rs"])
+ .args(&["run", "testNotPassed.rs"])
.current_dir("tests/fixture/failure/")
.assert()
.code(1);
@@ -94,7 +94,7 @@ fn run_single_test_not_passed() {
fn run_single_test_no_filename() {
Command::cargo_bin("rustlings")
.unwrap()
- .arg("r")
+ .arg("run")
.current_dir("tests/fixture/")
.assert()
.code(1);
@@ -104,17 +104,38 @@ fn run_single_test_no_filename() {
fn run_single_test_no_exercise() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "compNoExercise.rs"])
+ .args(&["run", "compNoExercise.rs"])
.current_dir("tests/fixture/failure")
.assert()
.code(1);
}
+#[test]
+fn reset_single_exercise() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .args(&["reset", "intro1"])
+ .assert()
+ .code(0);
+}
+
+#[test]
+fn reset_no_exercise() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .arg("reset")
+ .assert()
+ .code(1)
+ .stderr(predicates::str::contains(
+ "positional arguments not provided",
+ ));
+}
+
#[test]
fn get_hint_for_single_test() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["h", "testFailure"])
+ .args(&["hint", "testFailure"])
.current_dir("tests/fixture/failure")
.assert()
.code(0)
@@ -125,16 +146,24 @@ fn get_hint_for_single_test() {
fn all_exercises_require_confirmation() {
for exercise in glob("exercises/**/*.rs").unwrap() {
let path = exercise.unwrap();
+ if path.file_name().unwrap() == "mod.rs" {
+ continue;
+ }
let source = {
let mut file = File::open(&path).unwrap();
let mut s = String::new();
file.read_to_string(&mut s).unwrap();
s
};
- source.matches("// I AM NOT DONE").next().expect(&format!(
- "There should be an `I AM NOT DONE` annotation in {:?}",
- path
- ));
+ source
+ .matches("// I AM NOT DONE")
+ .next()
+ .unwrap_or_else(|| {
+ panic!(
+ "There should be an `I AM NOT DONE` annotation in {:?}",
+ path
+ )
+ });
}
}
@@ -142,7 +171,7 @@ fn all_exercises_require_confirmation() {
fn run_compile_exercise_does_not_prompt() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "pending_exercise"])
+ .args(&["run", "pending_exercise"])
.current_dir("tests/fixture/state")
.assert()
.code(0)
@@ -153,7 +182,7 @@ fn run_compile_exercise_does_not_prompt() {
fn run_test_exercise_does_not_prompt() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "pending_test_exercise"])
+ .args(&["run", "pending_test_exercise"])
.current_dir("tests/fixture/state")
.assert()
.code(0)
@@ -164,20 +193,74 @@ fn run_test_exercise_does_not_prompt() {
fn run_single_test_success_with_output() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["--nocapture", "r", "testSuccess"])
+ .args(&["--nocapture", "run", "testSuccess"])
.current_dir("tests/fixture/success/")
.assert()
.code(0)
- .stdout(predicates::str::contains("THIS TEST TOO SHALL PAS"));
+ .stdout(predicates::str::contains("THIS TEST TOO SHALL PASS"));
}
#[test]
fn run_single_test_success_without_output() {
Command::cargo_bin("rustlings")
.unwrap()
- .args(&["r", "testSuccess"])
+ .args(&["run", "testSuccess"])
.current_dir("tests/fixture/success/")
.assert()
.code(0)
- .stdout(predicates::str::contains("THIS TEST TOO SHALL PAS").not());
-}
\ No newline at end of file
+ .stdout(predicates::str::contains("THIS TEST TOO SHALL PASS").not());
+}
+
+#[test]
+fn run_rustlings_list() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .args(&["list"])
+ .current_dir("tests/fixture/success")
+ .assert()
+ .success();
+}
+
+#[test]
+fn run_rustlings_list_no_pending() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .args(&["list"])
+ .current_dir("tests/fixture/success")
+ .assert()
+ .success()
+ .stdout(predicates::str::contains("Pending").not());
+}
+
+#[test]
+fn run_rustlings_list_both_done_and_pending() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .args(&["list"])
+ .current_dir("tests/fixture/state")
+ .assert()
+ .success()
+ .stdout(predicates::str::contains("Done").and(predicates::str::contains("Pending")));
+}
+
+#[test]
+fn run_rustlings_list_without_pending() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .args(&["list", "--solved"])
+ .current_dir("tests/fixture/state")
+ .assert()
+ .success()
+ .stdout(predicates::str::contains("Pending").not());
+}
+
+#[test]
+fn run_rustlings_list_without_done() {
+ Command::cargo_bin("rustlings")
+ .unwrap()
+ .args(&["list", "--unsolved"])
+ .current_dir("tests/fixture/state")
+ .assert()
+ .success()
+ .stdout(predicates::str::contains("Done").not());
+}
