0% completed

All LessonsFree Lessons (5)

Welcome to Begin Rust

Introduction Instructions

Hello World and variables

Hello World What Does That Mean?Interpolation Variables More Math!Multiple Variables and Shadowing Types Summary Exercises

Anatomy of Rust

Introduction Pairing and Nesting Layout Comments Expressions, Values, and Types Variables, Again Effects Versus Results Blocks and Statements Summary Exercises

Functions

Hello World, Again Function Parameters Function Results Multiple Parameters Variable and Parameter Scope Anatomy of a Function Calling Functions Is main Special?Summary Exercises

Booleans

Equality Assertions Comparison Operators Functions Returning Booleans The Not Operator Not-ing Other Comparison Operators And/Or Summary Exercises

Conditionals

Hello If A Note on Semicolons Else Else If Evaluating to Values Factorial and Recursion Summary Exercises

Mutable variables and while loops

While Expressions/Loops Failed Attempt: Shadowing Almost Correct: Assignment More Than Once!Counting Sum Nested Loops Mutation and Shadowing Let Without Assignment Summary Exercises

Structs and ownership

All This Fruit!Struct Call Another Function Ownership and Moving Copy Values Make a Copy Move Out!Increasing Fruit Upper and Lower Case Summary Exercises

References

Borrow Mutable References What's In a Reference?Deref Lifetimes of References Mutating and Borrowing Multiple References Single Mutable Reference Mutable to Immutable Summary Exercises

Methods

Hello Method Calls!Type Inference Side Note: Underscores in Numbers Negative Numbers are Annoying Hello Method Implementations!Methods by Reference Static Methods The Self Type Method Call Chaining Summary Exercises

Strings

Bits, Bytes, and Memory Dynamically Sized Types Program Memory Lifetimes of String Literals Owned Strings The Type of Owned Strings Moving Strings Borrowing a String A Better Person The format! Macro Freeing Summary Exercises

Arrays, Vecs, and slices

Arrays Indexing Slices The Relation to String Slices Vec Slicing a Slice Summary Exercises

Type parameters

Parameterized Structs Parameterized Functions Parameterized impl Blocks Turbofish!Summary Exercises

Traits

Parameterized Fruit

Clone and Derive

Copy and Marker Traits

Partial Equal, Partial Order

Using Traits From std

Multiple Bounds

Associated Types

Enums

Get Me a Job Using Variants Pattern Matching Commas and Braces More Teachers Methods for Enums Optional Results Capturing with Match Summary Exercises

Iterators and for loops

Count to 10 Iterators Inclusive Range Expressions Iterating Over a Vec IntoIterator The Rule of 3 Arrays and Slices Iterating on Strings Generic Iterator Functions Summary Exercises

Early exit

Time for a Break Go On...Replacing For With While Returning The Favor Salaries Let Me Ask You a Question Failing With Style Errors in main Summary Exercises

What’s next?

Install Rust on Your Local Machine Do More Exercises Get Involved Thank you!

The Ultimate Guide to Rust Programming/

...

/

Trait Bounds

Trait Bounds

We'll cover the following...

I want to quadruple my numbers. I could do * 4, but that’s so pedestrian. I’ve already got a double method. So why not simply call it twice?

Press + to interact

fn quadruple(x: i32) -> i32 {
    x.double().double()
}
fn main() {
    println!("quadruple 5_i32 == {}", quadruple(5_i32));
}
trait Double {
    fn double(&self) -> Self;
}
impl Double for i32 {
    fn double(&self) -> Self {
        self * 2
    }
}
impl Double for i64 {
    fn double(&self) -> Self {
        self * 2
    }
}

That’s great, but it only works for an i32. If I try to call quadruple on an i64 I’ll get an error message about mismatched types. Fortunately, we’ve already learned all about type parameters. So, let’s say that our quadruple function works on any type:

Press + to interact

fn quadruple<T>(x: T) -> T {
    x.double().double()
}
fn main() {
    println!("quadruple 5_i32 == {}", quadruple(5_i32));
    println!("quadruple 5_i64 == {}", quadruple(5_i64));
}

The compiler does not like this, but it gives us some ...