Explore Rust’s unique features with 24 brain-teasing puzzles. Gain insights into Rust concepts, enhancing your skills and preparing for advanced topics after completing the course.

newrust.tar.gz

codewidgetrust

livewidgetrust

livewidgetrust-cargo-toml-release

codewidgetrust-cargo

livewidgetrust-cargo-main-toml-release

livewidgetrust-cargo-clippy

livewidgetrust-cargo-main-release

livewidgetrust-cargo-nightly

livewidgetrust-cargo-release-update

livewidgetrust-cargo-languages

livewidgetrust-shadow-same

livewidgetrust-shadow-reuse

livewidgetrust-shadow-unrelated

live-cargo-clippy

live-cargo-release-update

live-cargo-nightly

live-cargo-shadow-same

live-cargo-shadow-reuse

live-cargo-shadow-unrelated

live-cargo-sleepless

livewidgetrust-cargo-release-update-puzzle11

This course provides insights into Rust’s unique features by exploring them in 24 brain-teasing puzzles. Each puzzle is explained in its following lesson. Complete all 24, and by the time you’re done, your knowledge about different concepts in Rust will definitely be improved, and you will be ready to move on to more advanced concepts.

Rust Brain Teasers

# Test it out

Hit “Run” to see the code’s output.

fn double_it(n: i32) -> i32 {
    n * 2
}

fn double_it(n: f32) -> f32 {
    n * 2.0
}

fn main() {
    println!("2 * 4 = {}", double_it(2));
}

# Output

The program fails to compile, and we receive the following error message:

---
``` XML
error[E0428]: the name "double_it" is defined multiple times
```

# Explanation
In C++ and similar languages, redefining a function with different parameter types is known as **function overloading**. It allows us to provide similar functionality for multiple types without having to come up with a type-specific function name for each option. For example, the following is valid C++ code:

#include <iostream>
using namespace std;

float double_it(float n) { 
    return n * 2.0;
}
int double_it(int n) { 
    return n * 2;
}

int main() {
  cout << double_it(2);
  return 0;
}

Function overloading works in C++ and not in Rust because of name mangling. When a function is compiled, a compiler-specific name for the function is created and used by the linker to connect function calls to actual memory addresses. In C++, mangled names include both the function name and the types of the parameter. The functions `double_it(float)` and `double_it(int)` are different. Rust only mangles on the function name, so, even with different parameter lists, we can’t have two functions in the same namespace with the exact same name.

Rust provides us with a work-around. Instead of defining functions with multiple sets of parameters, Rust generics allow us to use a `generic` function that accepts multiple parameter types.

Let's learn how function overloading and variable overloading works in Rust.

Introduction

Puzzles

Wrapping it up

Puzzle 16: Explanation