rust/comprehensive-rust
1
0
Fork 0
mirror of https://github.com/google/comprehensive-rust.git synced 2025-04-28 17:55:41 +02:00
Code Issues Releases Activity

Simplify fizz buzz slide (#595)

Browse Source 
There is no need to introduce `match` here where we don’t have time to
talk about it in detail.
This commit is contained in:
Martin Geisler 2023-05-03 09:56:58 +02:00 committed by GitHub
parent 3b21053ff2
commit 4a09d053ac
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 14 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
src/basic-syntax/functions.md
View File

@ -4,28 +4,28 @@ A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz)
```rust,editable ```rust,editable
fn main() { fn main() {
fizzbuzz_to(20); // Defined below, no forward declaration needed print_fizzbuzz_to(20);
} }
fn is_divisible_by(lhs: u32, rhs: u32) -> bool { fn is_divisible(n: u32, divisor: u32) -> bool {
if rhs == 0 { if divisor == 0 {
return false; // Corner case, early return return false;
} }
lhs % rhs == 0 // The last expression in a block is the return value n % divisor == 0
} }
fn fizzbuzz(n: u32) -> () { // No return value means returning the unit type `()` fn fizzbuzz(n: u32) -> String {
match (is_divisible_by(n, 3), is_divisible_by(n, 5)) { let fizz = if is_divisible(n, 3) { "fizz" } else { "" };
(true, true) => println!("fizzbuzz"), let buzz = if is_divisible(n, 5) { "buzz" } else { "" };
(true, false) => println!("fizz"), if fizz.is_empty() && buzz.is_empty() {
(false, true) => println!("buzz"), return format!("{n}");
(false, false) => println!("{n}"),
} }
format!("{fizz}{buzz}")
} }
fn fizzbuzz_to(n: u32) { // `-> ()` is normally omitted fn print_fizzbuzz_to(n: u32) {
for i in 1..=n { for i in 1..=n {
fizzbuzz(i); println!("{}", fizzbuzz(i));
} }
} }
``` ```
@ -36,19 +36,6 @@ fn fizzbuzz_to(n: u32) { // `-> ()` is normally omitted
* Declaration parameters are followed by a type (the reverse of some programming languages), then a return type. * Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.
* The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the expression. * The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the expression.
* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted. * Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted.
* The range expression in the `for` loop in `fizzbuzz_to()` contains `=n`, which causes it to include the upper bound. * The range expression in the `for` loop in `print_fizzbuzz_to()` contains `=n`, which causes it to include the upper bound.
* The `match` expression in `fizzbuzz()` is doing a lot of work. It is expanded below to show what is happening.
(Type annotations added for clarity, but they can be elided.)
```rust,ignore
let by_3: bool = is_divisible_by(n, 3);
let by_5: bool = is_divisible_by(n, 5);
let by_35: (bool, bool) = (by_3, by_5);
match by_35 {
// ...
```
</details> </details>