@ -124,7 +124,7 @@ I am a Canadian who lives in Korea, and I wrote Easy Rust while thinking of how
- [Part 2 - Rust on your computer](#part-2---rust-on-your-computer)
- [Cargo](#cargo)
- [Taking_user_input](#taking-user-input)
- [Using files](#using-files)
- [Using files](#using-files)
- [Cargo doc](#cargo-doc)
- [The end?](#the-end?)
@ -163,7 +163,7 @@ fn main() {
}
```
When you do this, the compiler won't look at anything to the right of the `//`.
When you do this, the compiler won't look at anything to the right of the `//`.
There is another kind of comment that you write with `/*` to start and `*/` to end. This one is useful to write in the middle of your code.
@ -213,7 +213,7 @@ So what is `isize` and `usize`? This means the number of bits on your type of co
There are many reasons for the different types of integers. One reason is computer performance: a smaller number of bytes is faster to process. For example, the number -10 as an `i8` is `11110110`, but as an `i128` it is `11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110110`. But here are some other uses:
Characters in Rust are called `char`. Every `char` has a number: the letter `A` is number 65, while the character `友` ("friend" in Chinese) is number 21451. The list of numbers is called "Unicode". Unicode uses smaller numbers for characters that are used more, like A through Z, or digits 0 through 9, or space.
Characters in Rust are called `char`. Every `char` has a number: the letter `A` is number 65, while the character `友` ("friend" in Chinese) is number 21451. The list of numbers is called "Unicode". Unicode uses smaller numbers for characters that are used more, like A through Z, or digits 0 through 9, or space.
```rust
fn main() {
@ -235,7 +235,7 @@ fn main() { // main() is where Rust programs start to run. Code goes inside {} (
// so Rust chooses i32. Rust always
// chooses i32 for integers if you don't
// tell it to use a different type
println!("{}", my_number as char); // ⚠️
}
```
@ -259,7 +259,7 @@ fn main() {
}
```
It prints `d` because that is the `char` in place 100.
It prints `d` because that is the `char` in place 100.
The easier way, however, is just to tell Rust that `my_number` is a `u8`. Here's how you do it:
@ -920,7 +920,7 @@ you can write over
many lines
and it will print just fine.
If you forget to write
on the left side, the spaces
on the left side, the spaces
will be added when you print.
```
@ -938,7 +938,7 @@ This prints:
Here are two escape characters: \n and \t
```
Sometimes you have too many `"` and escape characters, and want Rust to ignore everything. To do this, you can add `r#` to the beginning and `#` to the end.
Sometimes you have too many `"` and escape characters, and want Rust to ignore everything. To do this, you can add `r#` to the beginning and `#` to the end.
```rust
fn main() {
@ -986,11 +986,10 @@ The hashtag #IceToSeeYou had become very popular.
fn main() {
let r#let = 6; // The variable's name is let
let mut r#mut = 10; // This variable's name is mut
}
```
`r#` has this function because older versions of Rust had fewer keywords than Rust now. So with `r#` you can avoid mistakes with variable names that were not keywords before.
`r#` has this function because older versions of Rust had fewer keywords than Rust now. So with `r#` you can avoid mistakes with variable names that were not keywords before.
Or maybe for some reason you *really* need a function to have a name like `return`. Then you can write this:
@ -1090,7 +1089,7 @@ fn main() {
}
```
This prints `Binary: 1000101011, hexadecimal: 22b, octal: 1053`.
This prints `Binary: 1000101011, hexadecimal: 22b, octal: 1053`.
Or you can add numbers to change the order. The first variable will be in index 0, the next in index 1, and so on.
@ -1133,7 +1132,7 @@ Very complex printing is also possible in Rust if you want to use it. Here is ho
{variable:padding alignment minimum.maximum}
To understand this, look at the
To understand this, look at the
1) Do you want a variable name? Write that first, like when we wrote {country} above.
(Then add a `:` after it if you want to do more things)
@ -1316,7 +1315,7 @@ fn main() {
}
```
This prints `Austria`.
This prints `Austria`.
In the code, `country` is a `String`. We then created two references to `country`. They have the type `&String`, which you say is a "reference to a String". We could create three references or one hundred references to `country` and it would be no problem.
This vector has 0 reallocations, which is better. So if you think you know how many elements you need, you can use `Vec::with_capacity()` to make it faster.
This vector has 0 reallocations, which is better. So if you think you know how many elements you need, you can use `Vec::with_capacity()` to make it faster.
You remember that you can use `.into()` to make a `&str` into a `String`. You can also use it to make an array into a `Vec`. You have to tell `.into()` that you want a `Vec`, but you don't have to choose the type of `Vec`. If you don't want to choose, you can write `Vec<_>`.
@ -1979,13 +1978,13 @@ fn main() {
## Tuples
Tuples in Rust use `()`. We have seen many empty tuples already, because *nothing* in a function actually means an empty tuple:
Tuples in Rust use `()`. We have seen many empty tuples already, because *nothing* in a function actually means an empty tuple:
```text
fn do_something() {}
```
is actually short for:
is actually short for:
```text
fn do_something() -> () {}
@ -2254,7 +2253,7 @@ Each colour has at least 10
Not much green
```
This also shows how `match` statements work, because in the first example it only printed `Not much blue`. But `first` also has not much green. A `match` statement always stops when it finds a match, and doesn't check the rest. This is a good example of code that compiles well but is not the code you want.
This also shows how `match` statements work, because in the first example it only printed `Not much blue`. But `first` also has not much green. A `match` statement always stops when it finds a match, and doesn't check the rest. This is a good example of code that compiles well but is not the code you want.
You can make a really big `match` statement to fix it, but it is probably better to use a `for` loop. We will talk about loops soon.
@ -2574,7 +2573,7 @@ fn main() {
}
```
It prints `Out of 1 to 10, my happiness is 7`. Let's import so we can type less. To import everything, write `*`. Note: it's the same key as `*` for dereferencing but is completely different.
It prints `Out of 1 to 10, my happiness is 7`. Let's import so we can type less. To import everything, write `*`. Note: it's the same key as `*` for dereferencing but is completely different.
```rust
enum Mood {
@ -2667,7 +2666,7 @@ This is a good-sized star.
What about DeadStar? It's the number 1001.
```
`DeadStar` would have been number 4, but now it's 1001.
`DeadStar` would have been number 4, but now it's 1001.
### Enums to use multiple types
@ -2963,7 +2962,7 @@ This is where you can start to give your structs and enums some real power. To c
- Regular methods: these take **self** (or **&self** or **&mut self**). Regular methods use a `.` (a period). `.clone()` is an example of a regular method.
- Associated methods (or "static" methods): these do not take self. Associated means "related to". They are written differently, using `::`. `String::from()` is an associated method, and so is `Vec::new()`. You usually see associated methods used create new variables.
In our example we are going to create animals and print them.
In our example we are going to create animals and print them.
For a new `struct` or `enum`, you need to give it **Debug** if you want to use `{:?}` to print, so we will do that. If you write `#[derive(Debug)]` above the struct or enum then you can print it with `{:?}`. These messages with `#[]` are called **attributes**. You can sometimes use them to tell the compiler to give your struct an ability like `Debug`. There are many attributes and we will learn about them later. But `derive` is probably the most common and you see it a lot above structs and enums.
@ -3459,7 +3458,7 @@ I have two things to say: Where is Padme? and Is she all right?
## Option and Result
We understand enums and generics now, so we can understand `Option` and `Result`. Rust uses these two enums to make code safer.
We understand enums and generics now, so we can understand `Option` and `Result`. Rust uses these two enums to make code safer.
We will start with `Option`.
@ -3584,7 +3583,7 @@ enum Option<T> {
fn main() {}
```
The important point to remember: with `Some`, you have a value of type `T` (any type). Also note that the square brackets after the `enum` name around `<T>` is what tells the compiler that it's generic. It has no trait like `Display` or anything to limit it, so it can be anything. But with `None`, you don't have anything.
The important point to remember: with `Some`, you have a value of type `T` (any type). Also note that the square brackets after the `enum` name around `<T>` is what tells the compiler that it's generic. It has no trait like `Display` or anything to limit it, so it can be anything. But with `None`, you don't have anything.
So in a `match` statement for Option you can't say:
@ -3812,7 +3811,7 @@ fn main() {
}
```
**Important to remember**: `if let Some(number) = my_vec.get(index)` means "if you get `Some(number)` from `my_vec.get(index)`".
**Important to remember**: `if let Some(number) = my_vec.get(index)` means "if you get `Some(number)` from `my_vec.get(index)`".
Also note: it uses one `=`. It is not a boolean.
@ -3953,7 +3952,7 @@ In the year 2020 the city of Tallinn had a population of 437619.
Now we will go back to `HashMap`.
You can get a value in a `HashMap` by just putting the key in `[]` square brackets. In this next example we will bring up the value for the key `Bielefeld`, which is `Germany`. But be careful, because the program will crash if there is no key. If you write `println!("{:?}", city_hashmap["Bielefeldd"]);` for example then it will crash, because `Bielefeldd` doesn't exist.
You can get a value in a `HashMap` by just putting the key in `[]` square brackets. In this next example we will bring up the value for the key `Bielefeld`, which is `Germany`. But be careful, because the program will crash if there is no key. If you write `println!("{:?}", city_hashmap["Bielefeldd"]);` for example then it will crash, because `Bielefeldd` doesn't exist.
If you are not sure that there will be a key, you can use `.get()` which returns an `Option`. If it exists it will be `Some(value)`, and if not you will get `None` instead of crashing the program. That's why `.get()` is the safer way to get a value from a `HashMap`.
@ -3975,7 +3974,7 @@ fn main() {
println!("{:?}", city_hashmap["Bielefeld"]);
println!("{:?}", city_hashmap.get("Bielefeld"));
println!("{:?}", city_hashmap.get("Bielefeldd"));
println!("{:?}", city_hashmap.get("Bielefeldd"));
}
```
@ -3996,13 +3995,13 @@ use std::collections::HashMap;
fn main() {
let mut book_hashmap = HashMap::new();
book_hashmap.insert(1, "L'Allemagne Moderne");
book_hashmap.insert(1, "Le Petit Prince");
book_hashmap.insert(1, "섀도우 오브 유어 스마일");
book_hashmap.insert(1, "Eye of the World");
println!("{:?}", book_hashmap.get(&1));
println!("{:?}", book_hashmap.get(&1));
}
```
@ -4028,7 +4027,6 @@ fn main() {
This prints `Some("L\'Allemagne Moderne")` because there was already a key for `1`, so we didn't insert `Le Petit Prince`.
`HashMap` has a very interesting method called `.entry()` that you definitely want to try out. With it you can try to make an entry and use another method like `.or_insert()` to insert the value if there is no key. The interesting part is that it also gives a mutable reference so you can change it if you want. First is an example where we just insert `true` every time we insert a book title into the `HashMap`.
Let's pretend that we have a library and want to keep track of our books.
[Here is the page for Entry](https://doc.rust-lang.org/std/collections/hash_map/enum.Entry.html). Here is a simple version of its code. `K` means key and `V` means variable.
```rust
// 🚧
// 🚧
use std::collections::hash_map::*;
enum Entry<K,V> {
@ -4205,7 +4203,7 @@ This prints:
```text
There are 66 unique numbers, so we are missing 34.
A `BTreeSet` is similar to a `HashSet` in the same way that a `BTreeMap` is similar to a `HashMap`. If we print each item in the `HashSet`, we don't know what the order will be:
@ -4246,14 +4244,14 @@ Now it will print in order: `0 3 5 8 10 11 13 14 15 16 17 18 19 20 22 24 25 26 2
### BinaryHeap
A `BinaryHeap` is an interesting collection type, because it is mostly unordered but has a bit of order. It keeps the largest item in the front, but the other items are in any order.
A `BinaryHeap` is an interesting collection type, because it is mostly unordered but has a bit of order. It keeps the largest item in the front, but the other items are in any order.
We will use another list of items for an example, but this time smaller.
```rust
use std::collections::BinaryHeap;
use std::collections::BinaryHeap;
fn show_remainder(input: &BinaryHeap<i32>) -> Vec<i32> { // This function shows the remainder in the BinaryHeap. Actually an iterator would be
fn show_remainder(input: &BinaryHeap<i32>) -> Vec<i32> { // This function shows the remainder in the BinaryHeap. Actually an iterator would be
// faster than a function - we will learn them later.
let mut remainder_vec = vec![];
for number in input {
@ -4299,7 +4297,7 @@ use std::collections::BinaryHeap;
fn main() {
let mut jobs = BinaryHeap::new();
// Add jobs to do throughout the day
// Add jobs to do throughout the day
jobs.push((100, "Write back to email from the CEO"));
jobs.push((80, "Finish the report today"));
jobs.push((5, "Watch some YouTube"));
@ -4353,7 +4351,7 @@ fn main() {
}
```
This is a `Vec` of 600,000 zeros. Every time you use `remove(0)` on it, it moves each zero left one space to the left. And then it does it 600,000 times.
This is a `Vec` of 600,000 zeros. Every time you use `remove(0)` on it, it moves each zero left one space to the left. And then it does it 600,000 times.
You don't have to worry about that with a `VecDeque`. It is usually a bit slower than a `Vec`, but if you have to do things on both ends then it is much faster. You can just use `VecDeque::from` with a `Vec` to make one. Our code above then looks like this:
@ -4387,7 +4385,7 @@ fn check_remaining(input: &VecDeque<(&str, bool)>) { // Each item is a (&str, bo
fn done(input: &mut VecDeque<(&str, bool)>) {
let mut task_done = input.pop_back().unwrap(); // pop off the back
task_done.1 = true; // now it's done - mark as true
task_done.1 = true; // now it's done - mark as true
input.push_front(task_done); // put it at the front now
}
@ -4414,7 +4412,7 @@ This prints:
```text
You must: phone Loki back
("add new product to list", true) ("send email to customer", true) ("phone Loki back", false)
("add new product to list", true) ("send email to customer", true) ("phone Loki back", false)
So it is saying "you said that left != right, but left == right". And it displays our message that says `You entered Mithridates. Input must not equal Mithridates`.
`unwrap` is also good when you are writing your program and you want it to crash when there is a problem. Later, when your code is finished it is good to change `unwrap` to something else that won't crash.
`unwrap` is also good when you are writing your program and you want it to crash when there is a problem. Later, when your code is finished it is good to change `unwrap` to something else that won't crash.
You can also use `expect`, which is like `unwrap` but a bit better because you give it your own message. Textbooks usually give this advice: "If you use `.unwrap()` a lot, at least use `.expect()` for better error messages."
@ -4702,8 +4700,8 @@ fn main() {
It crashes again, but the error is better: `thread 'main' panicked at 'Input vector needs at least 4 items', src\main.rs:7:18`. `.expect()` is a little better than `.unwrap()` because of this, but it will still panic on `None`. Now here is an example of a bad practice, a function that tries to unwrap two times. It takes a `Vec<Option<i32>>`, so maybe each part will have a `Some<i32>` or maybe a `None`.
```rust
fn try_two_unwraps(input: Vec<Option<i32>>) {
println!("Index 0 is: {}", input[0].unwrap());
fn try_two_unwraps(input: Vec<Option<i32>>) {
println!("Index 0 is: {}", input[0].unwrap());
println!("Index 1 is: {}", input[1].unwrap());
}
@ -4732,7 +4730,7 @@ So that is a bit better: `thread 'main' panicked at 'The first unwrap had a None
You can also use `unwrap_or` if you want to always have a value that you want to choose. If you do this it will never panic. That's:
- 1) good because your program won't panic, but
- 1) good because your program won't panic, but
- 2) maybe not good if you want the program to panic if there's a problem.
But usually we don't want our program to panic, so `unwrap_or` is a good method to use.
["Barack Hussein Obama", "Bill Jefferson Clinton"] }
```
@ -7376,7 +7373,7 @@ fn main() {
}
```
This prints:
This prints:
```text
Billy has 100000 hit points.
@ -7872,7 +7869,7 @@ fn main() {
}
```
So what if you want an actual new type?
So what if you want an actual new type?
If you want a new file type that the compiler sees as a `File`, you can put it in a struct:
@ -8321,11 +8318,11 @@ fn main() {
But that is a silly way to give the threads time to finish. The better way is to bind the threads to a variable. If you add `let`, then you will create a `JoinHandle`. You can see this in the signature for `spawn`:
```text
pub fn spawn<F,T>(f: F) -> JoinHandle<T>
pub fn spawn<F,T>(f: F) -> JoinHandle<T>
where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
T: Send + 'static,
```
(`f` is the closure - we will learn how to put closures into our functions later)
@ -8524,7 +8521,7 @@ You can make your own functions that take closures, but inside them it is less f
`fn all<F>`: this tells you that there is a generic type `F`. A closure is always generic because every time it is a different type.
`(&mut self, f: F)`: `&mut self` tells you that it's a method. `f: F` is usually what you see for a closure: this is the variable name and the type. Of course, there is nothing special about `f` and `F` and they could be different names. You could write `my_closure: Closure` if you wanted - it doesn't matter. But in signatures you almost always see `f: F`.
`(&mut self, f: F)`: `&mut self` tells you that it's a method. `f: F` is usually what you see for a closure: this is the variable name and the type. Of course, there is nothing special about `f` and `F` and they could be different names. You could write `my_closure: Closure` if you wanted - it doesn't matter. But in signatures you almost always see `f: F`.
Next is the part about the closure: `F: FnMut(Self::Item) -> bool`. Here it decides that the closure is `FnMut`, so it can change the values. It changes the values of `Self::Item`, which is the iterator that it takes. And it has to return `true` or `false`.
character_fear = daytime(character_fear); // Call the closures on Simon's fear. They give a message and change the fear number.
// In real life we would have a Character struct and use it as a method instead,
// like this: character_fear.daytime()
@ -9007,7 +9004,7 @@ fn main() {
}
});
handle_vec.push(handle); // save the handle so we can call join on it outside of the loop
// If we don't push it in the vec, it will just die here
// If we don't push it in the vec, it will just die here
}
handle_vec.into_iter().for_each(|handle| handle.join().unwrap()); // call join on all handles
@ -9411,7 +9408,7 @@ Of course, dealing with dead code and unused variables is important. But sometim
```rust
// ⚠️
#[derive(Display)]
#[derive(Display)]
struct HoldsAString {
the_string: String,
}
@ -9430,7 +9427,7 @@ error: cannot find derive macro `Display` in this scope
--> src\main.rs:2:10
|
2 | #[derive(Display)]
|
|
```
But for traits that you can automatically derive, you can put in as many as you like. Let's give `HoldsAString` seven traits in a single line, just for fun, even though it only needs one.
@ -9460,7 +9457,7 @@ struct NumberAndBool {
fn does_nothing(input: NumberAndBool) {
}
}
fn main() {
let number_and_bool = NumberAndBool {
@ -9468,13 +9465,12 @@ fn main() {
true_or_false: true
};
does_nothing(number_and_bool);
does_nothing(number_and_bool);
does_nothing(number_and_bool); // If it didn't have copy, this would make an error
}
```
`#[cfg()]` means configuration and tells the compiler whether to run code or not. You see it usually like this: `#[cfg(test)]`. You use that when writing test functions so that it knows not to run them unless you are testing. Then you can have tests next to your code but the compiler won't run them unless you tell it to.
`#[cfg()]` means configuration and tells the compiler whether to run code or not. You see it usually like this: `#[cfg(test)]`. You use that when writing test functions so that it knows not to run them unless you are testing. Then you can have tests next to your code but the compiler won't run them unless you tell it to.
One other example using `cfg` is `#[cfg(target_os = "windows")]`. With that you can tell the compiler to only run the code on Windows, or Linux, or anything else.
@ -10174,9 +10170,9 @@ fn main() {
.weight(100)
.build(); // This character is okay. Name is fine, height and weight are fine
// Now they are not Character, they are Result<Character,String>. So let's put them in a Vec so we can see them:
// Now they are not Character, they are Result<Character,String>. So let's put them in a Vec so we can see them:
let character_vec = vec![character_with_smurf, character_too_tall, character_too_heavy, okay_character];
for character in character_vec { // Now we will print the character if it's Ok, and print the error if it's Err
So you can see that `Deref` gives your type a lot of power.
So you can see that `Deref` gives your type a lot of power.
This is also why the standard library says: `Deref should only be implemented for smart pointers to avoid confusion`. That's because you can do some strange things with `Deref` for a complicated type. Let's imagine a really confusing example to understand what they mean. We'll start with `Character` struct for a game. A new `Character` needs some stats like intelligence and strength. So here is our first character:
let mut hit_points_vec = vec![]; // Put our hit points data in here
hit_points_vec.push(*billy); // Push *billy?
hit_points_vec.push(*brandy); // Push *brandy?
println!("{:?}", hit_points_vec);
hit_points_vec.push(*billy); // Push *billy?
hit_points_vec.push(*brandy); // Push *brandy?
println!("{:?}", hit_points_vec);
}
```
This just prints `[5, 5]`. Our code is now very strange for someone to read. We can read `Deref` just above `main()` and figure out that `*billy` means `i8`, but what if there was a lot of code? Maybe our code is 2000 lines long, and suddenly we have to figure out why we are `.push()`ing `*billy`. `Character` is certainly more than just a smart pointer for `i8`.
This just prints `[5, 5]`. Our code is now very strange for someone to read. We can read `Deref` just above `main()` and figure out that `*billy` means `i8`, but what if there was a lot of code? Maybe our code is 2000 lines long, and suddenly we have to figure out why we are `.push()`ing `*billy`. `Character` is certainly more than just a smart pointer for `i8`.
Of course, it is not illegal to write `hit_points_vec.push(*billy)`, but it makes the code look very strange. Probably a simple `.get_hp()` method would be much better, or another struct that holds the characters. Then you could iterate through and push the `hit_points` for each one. `Deref` gives a lot of power but it's good to make sure that the code is logical.
@ -10619,7 +10614,7 @@ fn main() {
}
```
This prints:
This prints:
```text
6
@ -10662,8 +10657,6 @@ mod print_things {
pub fn prints_one_thing<T:Display>(input: T) {
println!("{}", input)
}
}
fn main() {
@ -10671,7 +10664,6 @@ fn main() {
let my_billy = Billy::new(3);
my_billy.print_billy();
}
```
@ -10685,7 +10677,7 @@ This will print:
By the way, the `*` to import everything is called the "glob operator". Glob means "global", so it means everything.
Inside a `mod` you can create other mods. A child mod (a mod inside of a mod) can always use anything inside a parent mod. You can see this in the next example where we have a `mod city` inside a `mod province` inside a `mod country`.
Inside a `mod` you can create other mods. A child mod (a mod inside of a mod) can always use anything inside a parent mod. You can see this in the next example where we have a `mod city` inside a `mod province` inside a `mod country`.
You can think of the structure like this: even if you are in a country, you might not be in a province. And even if you are in a province, you might not be in a city. But if you are in a city, you are in its province and you are its country.
name: format!("{} and {}", self.name, other.name), // We will add the names together,
population: self.population + other.population, // and the population,
population: self.population + other.population, // and the population,
gdp: self.gdp + other.gdp, // and the GDP
}
}
@ -11946,8 +11938,8 @@ fn main() {
let vanuatu = Country::new("Vanuatu", 307_815, 820_000_000);
let micronesia = Country::new("Micronesia", 104_468, 367_000_000);
// We could have given Country a &str instead of a String for the name. But we would have to write lifetimes everywhere
// and that would be too much for a small example. Better to just clone them when we call println!.
// We could have given Country a &str instead of a String for the name. But we would have to write lifetimes everywhere
// and that would be too much for a small example. Better to just clone them when we call println!.
println!("{}", nauru.clone());
println!("{}", nauru.clone() + vanuatu.clone());
println!("{}", nauru + vanuatu + micronesia);
@ -12119,7 +12111,7 @@ fn main() {
capacity_counter = push_string.capacity(); // then update the counter
}
push_string.push_str("I'm getting pushed into the string!"); // and push this in every time
}
}
}
```
@ -12158,7 +12150,7 @@ fn main() {
capacity_counter = push_string.capacity();
}
push_string.push_str("I'm getting pushed into the string!");
}
}
}
```
@ -12176,17 +12168,17 @@ fn main() {
capacity_counter = push_string.capacity();
}
push_string.push_str("I'm getting pushed into the string!");
}
}
push_string.shrink_to_fit();
println!("{}", push_string.capacity());
println!("{}", push_string.capacity());
push_string.push('a');
println!("{}", push_string.capacity());
println!("{}", push_string.capacity());
push_string.shrink_to_fit();
println!("{}", push_string.capacity());
println!("{}", push_string.capacity());
}
```
This prints:
This prints:
```text
4587520
@ -12340,7 +12332,7 @@ impl fmt::Display for Ring { // Display to show who has it and who wants it
}
fn main() {
let mut one_ring = Ring::new("Frodo", "Gollum", "Sauron"); //
let mut one_ring = Ring::new("Frodo", "Gollum", "Sauron");
println!("{}", one_ring);
mem::swap(&mut one_ring.owner, &mut one_ring.former_owner); // Gollum got the ring back for a second
println!("{}", one_ring);
@ -12396,9 +12388,9 @@ One function called `.take()` is like `.replace()` but it leaves the default val
```rust
// 🚧
pub fn take<T>(dest: &mut T) -> T
pub fn take<T>(dest: &mut T) -> T
where
T: Default,
T: Default,
```
So you can do something like this:
@ -12554,7 +12546,7 @@ The standard library has a prelude too, which is why you don't have to write thi
What if you don't want the prelude for some reason? Just add the attribute `#![no_implicit_prelude]`. Let's give it a try and watch the compiler complain:
```rust
// ⚠️
// ⚠️
#![no_implicit_prelude]
fn main() {
let my_vec = vec![8, 9, 10];
@ -13391,7 +13383,7 @@ This will print something like `b c g h e a`. But we want to see what `cargo` do
So it looks like it didn't just bring in `rand`, but some others too. That's because we need `rand` for our crate, but `rand` also has some code that needs other crates too. So `cargo` will find all the crates we need and put them together. In our case we only had seven, but on very big projects you may have 200 or more crates to bring in.
Sudo Nice
4 years ago