From f8da722d429d126062d13dd45fb2e08eff173c50 Mon Sep 17 00:00:00 2001 From: Tanish-Eagle Date: Wed, 4 May 2022 14:02:32 +0530 Subject: [PATCH 1/3] Fixed the mistakes in match-iflet --- en/src/pattern-match/match-iflet.md | 54 ++++++++++++++--------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/en/src/pattern-match/match-iflet.md b/en/src/pattern-match/match-iflet.md index e4c3c3f..767205c 100644 --- a/en/src/pattern-match/match-iflet.md +++ b/en/src/pattern-match/match-iflet.md @@ -1,10 +1,10 @@ -# match, if let +# Match, if let -### match +### Match 1. 🌟🌟 ```rust,editable -// fill the blanks +// Fill the blanks enum Direction { East, West, @@ -16,7 +16,7 @@ fn main() { let dire = Direction::South; match dire { Direction::East => println!("East"), - __ => { // matching South or North here + __ => { // Matching South or North here println!("South or North"); }, _ => println!(__), @@ -24,13 +24,13 @@ fn main() { } ``` -2. 🌟🌟 match is an expression, so we can use it in assignments +2. 🌟🌟 Match is an expression, so we can use it in assignments. ```rust,editable fn main() { let boolean = true; - // fill the blank with an match expression: + // Fill the blank with a match expression: // // boolean = true => binary = 1 // boolean = false => binary = 0 @@ -38,14 +38,14 @@ fn main() { assert_eq!(binary, 1); - println!("Success!") + println!("Success!"); } ``` -3. 🌟🌟 using match to get the data an enum variant holds +3. 🌟🌟 Using match to get the data an enum variant holds. ```rust,editable -// fill in the blanks +// Fill in the blanks enum Message { Quit, Move { x: i32, y: i32 }, @@ -64,7 +64,7 @@ fn main() { show_message(msg) } - println!("Success!") + println!("Success!"); } fn show_message(msg: Message) { @@ -82,8 +82,8 @@ fn show_message(msg: Message) { } ``` -### matches! -[`matches!`](https://doc.rust-lang.org/stable/core/macro.matches.html) looks like `match`, but can do something different +### Matches! +[`matches!`](https://doc.rust-lang.org/stable/core/macro.matches.html) looks like `match`, but can do something different. 4. 🌟🌟 ```rust,editable @@ -91,12 +91,12 @@ fn show_message(msg: Message) { fn main() { let alphabets = ['a', 'E', 'Z', '0', 'x', '9' , 'Y']; - // fill the blank with `matches!` to make the code work + // Fill the blank with `matches!` to make the code work for ab in alphabets { assert!(__) } - println!("Success!") + println!("Success!"); } ``` @@ -113,19 +113,19 @@ fn main() { let v = vec![MyEnum::Foo,MyEnum::Bar,MyEnum::Foo]; for e in v { - if e == MyEnum::Foo { // fix the error with changing only this line + if e == MyEnum::Foo { // Fix the error by changing only this line count += 1; } } assert_eq!(count, 2); - println!("Success!") + println!("Success!"); } ``` -### if let -For some cases, when matching enums, `match` is too heavy, we can use `if let` instead. +### If let +For some cases, when matching enums, `match` is too heavy. We can use `if let` instead. 6. 🌟 ```rust,editable @@ -133,12 +133,12 @@ For some cases, when matching enums, `match` is too heavy, we can use `if let` i fn main() { let o = Some(7); - // remove the whole `match` block, using `if let` instead + // Remove the whole `match` block, using `if let` instead match o { Some(i) => { println!("This is a really long string and `{:?}`", i); - println!("Success!") + println!("Success!"); } _ => {} }; @@ -148,7 +148,7 @@ fn main() { 7. 🌟🌟 ```rust,editable -// fill in the blank +// Fill in the blank enum Foo { Bar(u8) } @@ -159,7 +159,7 @@ fn main() { __ { println!("foobar holds the value: {}", i); - println!("Success!") + println!("Success!"); } } ``` @@ -176,7 +176,7 @@ enum Foo { fn main() { let a = Foo::Qux(10); - // remove the codes below, using `match` instead + // Remove the codes below, using `match` instead if let Foo::Bar = a { println!("match foo::bar") } else if let Foo::Baz = a { @@ -191,15 +191,15 @@ fn main() { 9. 🌟🌟 ```rust,editable -// fix the errors in-place +// Fix the errors in-place fn main() { let age = Some(30); - if let Some(age) = age { // create a new variable with the same name as previous `age` + if let Some(age) = age { // Create a new variable with the same name as previous `age` assert_eq!(age, Some(30)); - } // the new variable `age` goes out of scope here + } // The new variable `age` goes out of scope here match age { - // match can also introduce a new shadowed variable + // Match can also introduce a new shadowed variable Some(age) => println!("age is a new variable, it's value is {}",age), _ => () } From 4f821522a5f76d2d1c924b9eba9b22443b229182 Mon Sep 17 00:00:00 2001 From: Tanish-Eagle Date: Wed, 4 May 2022 14:42:49 +0530 Subject: [PATCH 2/3] Fixed the mistakes in patterns --- en/src/pattern-match/patterns.md | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/en/src/pattern-match/patterns.md b/en/src/pattern-match/patterns.md index cddc1e2..35b0813 100644 --- a/en/src/pattern-match/patterns.md +++ b/en/src/pattern-match/patterns.md @@ -1,16 +1,16 @@ # Patterns -1. 🌟🌟 use `|` to match several values, use `..=` to match a inclusive range +1. 🌟🌟 Use `|` to match several values, use `..=` to match an inclusive range. ```rust,editable fn main() {} fn match_number(n: i32) { match n { - // match a single value + // Match a single value 1 => println!("One!"), - // fill in the blank with `|`, DON'T use `..` ofr `..=` + // Fill in the blank with `|`, DON'T use `..` or `..=` __ => println!("match 2 -> 5"), - // match an inclusive range + // Match an inclusive range 6..=10 => { println!("match 6 -> 10") }, @@ -21,7 +21,7 @@ fn match_number(n: i32) { } ``` -2. 🌟🌟🌟 The `@` operator lets us create a variable that holds a value at the same time we are testing that value to see whether it matches a pattern. +2. 🌟🌟🌟 The `@` operator lets us create a variable that holds a value, at the same time we are testing that value to see whether it matches a pattern. ```rust,editable struct Point { @@ -30,12 +30,12 @@ struct Point { } fn main() { - // fill in the blank to let p match the second arm + // Fill in the blank to let p match the second arm let p = Point { x: __, y: __ }; match p { Point { x, y: 0 } => println!("On the x axis at {}", x), - // second arm + // Second arm Point { x: 0..=5, y: y@ (10 | 20 | 30) } => println!("On the y axis at {}", y), Point { x, y } => println!("On neither axis: ({}, {})", x, y), } @@ -46,7 +46,7 @@ fn main() { ```rust,editable -// fix the errors +// Fix the errors enum Message { Hello { id: i32 }, } @@ -69,7 +69,7 @@ fn main() { 4. 🌟🌟 A match guard is an additional if condition specified after the pattern in a match arm that must also match, along with the pattern matching, for that arm to be chosen. ```rust,editable -// fill in the blank to make the code work, `split` MUST be used +// Fill in the blank to make the code work, `split` MUST be used fn main() { let num = Some(4); let split = 5; @@ -79,14 +79,14 @@ fn main() { None => (), } - println!("Success!") + println!("Success!"); } ``` 5. 🌟🌟 Ignoring remaining parts of the value with `..` ```rust,editable -// fill the blank to make the code work +// Fill the blank to make the code work fn main() { let numbers = (2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048); @@ -97,11 +97,11 @@ fn main() { } } - println!("Success!") + println!("Success!"); } ``` -6. 🌟🌟 Using pattern `&mut V` to match a mutable reference needs you to be very careful due to `V` being a value after matching +6. 🌟🌟 Using pattern `&mut V` to match a mutable reference needs you to be very careful, due to `V` being a value after matching. ```rust,editable // FIX the error with least changing From a2efc570a7db2283173978bd48354161c4f9e63e Mon Sep 17 00:00:00 2001 From: Sunface Date: Thu, 5 May 2022 08:33:09 +0800 Subject: [PATCH 3/3] Update en/src/pattern-match/match-iflet.md --- en/src/pattern-match/match-iflet.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/en/src/pattern-match/match-iflet.md b/en/src/pattern-match/match-iflet.md index 767205c..ea68dfd 100644 --- a/en/src/pattern-match/match-iflet.md +++ b/en/src/pattern-match/match-iflet.md @@ -82,7 +82,7 @@ fn show_message(msg: Message) { } ``` -### Matches! +### matches! [`matches!`](https://doc.rust-lang.org/stable/core/macro.matches.html) looks like `match`, but can do something different. 4. 🌟🌟