In this post, we'll try to give you a taste of Rust's key features so you may get a feel for the language. We'll touch on the type system, some handy functional features, traits, and more!

Rust is a systems programming language that was conceived at Mozilla and is now developed by a larger community. Initially, its purpose was to help rewrite portions of Firefox's codebase (largely C/C++) to improve its safety and security. It has since enjoyed growing adoption in fields such as

Rust is a statically typed language that emphasizes static code analysis, helpful compilation errors, convenient and comprehensive tooling, memory and concurrency safety, sheer performance, and abstractions that incur no (or little) runtime cost. Its memory model avoids the overhead of a garbage collector, but at the same time, the language's compiler enforces a set of rules that effectively prevent memory errors common in C/C++ applications.

This is not a comprehensive "learn Rust in one hour" guide. It should, however, give you a little taste of what the language is about and help you decide if it's for you! We will guide you through some of the key concepts you'll inevitably stumble into in Rust code, including custom types, error handling, ownership, closures, higher-order functions, iterators, pattern matching, and traits.

This guide is intended for people with some prior high-level programming experience, though which particular language(s) you've previously worked with shouldn't overly matter.

If you'd like to give the snippets a run, the easiest way is to use the 

 online. If you prefer to run things locally, the 

 will help you get your environment and a "Hello, World" project set up!

A comprehensive static type system means safer code and fewer manual tests that need to be written. The more information you can encode in the type system, the more Rust can check for free during compilation, allowing greater confidence in the correctness and reliability of your programs!

struct Point {
    x: f64, // f64 is a 64-bit float
    y: f64,
}

Rust also has enums for when a thing can be either this or that. Enums have variants. An enum value can only be set to one variant.

enum InboxState {
    Empty,
    OneMessage(String),
    TwoMessages(String, String),
}

Both structs and enums can be generic and accept arbitrary concrete types inside. This is possible by declaring type variables in angle brackets (

// T can be any type in this struct. It's a type variable.
struct Wrapper<T> {
    value: T,
}

fn main() {
    let foo = Wrapper {
        value: 2.5,
    };
}

In the example above, the compiler will deduce that 

 is not a dynamic type! It's resolved during compilation.

 statement is how you declare a local variable. It accepts type annotations, but most of the time they're not necessary - Rust might be a disciplined and strongly-typed language, but it's fairly smart and able to infer types itself a lot of the time.

You can add methods to any type you define using 

struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn print_info(&self) {
        println!("x: {}, y: {}", self.x, self.y);
    }
}

fn main() {
    let p = Point {x: 0.0, y: 1.5};
    
    p.print_info();
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

 is the type of the actual return value. 

A function that may fail should return a 

 - like the one below that attempts to sum a vector, but fails if it's empty.

fn my_sum(vector: Vec<f64>) -> Result<f64, ()> {
    if vector.is_empty() {
        return Err(());
    }
    
    let sum = vector.iter().sum();
    
    Ok(sum)
}

 is often used to signify nothing is returned. In this case, we're basically saying we don't want to add any extra error information if the function fails - we just want to know that it failed. In "real" Rust code, it's generally a good idea to provide an error type that implements the 

 trait, but that's outside of our scope right now.

 function now, we cannot ignore the fact it might produce an error. The snippet below won't work.

fn main() {
    let vector = vec!(10.2, 0.0, 5.5);
    
    let sum_plus_one = my_sum(vector) + 1.0;
    
    println!("{}", sum_plus_one);
}

The compiler tells us the result of summing is really a 

, and so cannot be added to a float. First, we need to unpack the value inside the 

One verbose way to handle the error (by crashing the whole application) looks like this:

fn main() {
    let vector = vec!(10.2, 0.0, 5.5);
    
    let sum = match sum(vector) {
        Ok(value) => value,
        Err(())   => panic!("empty vector"),
    };
    let sum_plus_one = sum + 1.0;
    
    println!("{}", sum_plus_one);
}

 statement isn't some special construct for error-handling. It can be used for pattern-matching against any enum. We'll talk about it later. This is the power of Rust's approach to error-handling: there's no magic. You get to use the same control flow as you would for the rest of your code.

There's of course shorthand for the above:

fn main() {
    let vector = vec!(10.2, 0.0, 5.5);
    
    let sum = sum(vector).expect("empty vector");
    let sum_plus_one = sum + 1.0;
    
    println!("{}", sum_plus_one);
}

Another strong point for Rust is that even if you don't use the 

 value (sometimes there is none), the compiler will still nudge you about having unchecked results. Forgetting about potential problems isn't easy.

 hackery, Rust doesn't have null values. Let's define a struct Foo.

 number inside. Thanks to that, if you write a function that accepts 

, you don't have to worry about handling a potentially null value. The compiler will make sure only valid, initialized data gets passed to the function.

What if we want to express that a variable can hold nothing? This is one place where generic enums come in handy. The standard library defines this 

pub enum Option<T> {
    None,
    Some(T),
}

#[derive(Debug)]
struct Foo {
    foo: f64,
}

fn main() {
    // `stuff` is of type `Option<Foo>`
    let stuff = Some(Foo {foo: 2.5});
    
    match stuff {
        Some(foo) => println!("We have {:?} inside!", foo),
        None      => println!("There's nothing here!"),
    }
}

Every computer program has to manage the memory used for its data. When some data is no longer used, the memory it occupied should be freed. After it is freed, the program should never attempt to access that data again, or face bugs.

. Thanks to those, this de-allocation and proper use are not something the programmer needs to be concerned with. This, however, introduces some performance overhead.

Unlike most high-level languages, Rust doesn't have a garbage collector. Instead, there's the model of ownership and borrow checking.

Ownership is a key concept in Rust. The idea is that, at any time, every bit of data in memory has exactly one owner. When that owner goes out of scope, the data is tossed out.

It is also possible to create references to owned data. These do not affect how long the data lives, but for your program to compile, the compiler has to ascertain that the references aren't used after the owner goes out of scope and the data is no more.

fn main() {
    let foo_ref;

    { // start a new scope
        let foo = String::from("Hi!"); // foo is the owner of the String
        foo_ref = &foo;                // foo_ref is an (immutable) reference
        
        println!("{}", foo_ref);       // this is okay
    } // `foo` goes out of scope here, so the data is gone
    
    println!("{}", foo_ref);           // this causes a compile error
}

If you try to compile the above snippet, you'll get this:

By default, a reference is immutable. To create a mutable reference, you have to add the 

fn main() {
    let mut foo = String::from("Hi!");
    let foo_ref = &mut foo;
    
    *foo_ref = String::from("Lo!");
    
    println!("{}", foo);
}

 keyword allows mutation to the owned data at all. The 

 creates a mutable reference, which is then stored in 

 dereferences the reference to get access to the underlying data and modify it through assignment.

You can have many immutable references, but you can only have one mutable reference. While you hold a mutable reference, you cannot use the owner or have any other (mutable or not) reference. This is to prevent data races and mistakes.

All illegal use of references causes compilation errors and forces you to fix your code before it ever has a chance to see production!

One amazing thing about Rust is it brings some high-level abstractions inspired by cutting edge languages to the world of systems programming.

Rust supports closures - anonymous functions capable of dynamically capturing the variables from the encompassing scope. These can be treated like any other value and assigned to variables. Those variables can then be called the same way regular functions can.

fn main() {
    let num_to_capture = 42;
    let num_printer = |x| println!("x: {}, captured: {}", x, num_to_capture);
    
    num_printer(5);
}

prints two numbers, but they're passed through different mechanisms. The 

 argument has to be provided when calling 

This becomes much more interesting when combined with higher-order functions - functions that accept other functions as arguments and/or return a function. Say a third-party library defines a function called 

 and allows you to extend the behavior of it by providing a callback. This is your chance to get partial results printed for the user currently logged in.

fn main() {
    let user = "Bob";
    let num_printer = |x| println!("{}'s result: {}", user, x);

    perform_calculations(num_printer);
}

fn perform_calculations(callback: impl Fn(u32)) {
    // some expensive calculations

    let result = 5;
    callback(result);
  
    // some more expensive stuff
}

Iterators are a major feature of Rust. They can be very convenient.

Ranges of numbers are iterators. Iterators can be iterated on in a 

fn main() {
    for i in 2..10 {
        println!("{}", i);
    }
}

A borrowing iterator can be created for any collection, e.g. an array.

fn main() {
    for char in ['a', 'b', 'c'].iter() {
        println!("{}", char);
    }
}

It's possible to turn your own custom types into iterators by implementing the 

There's one more way to execute something on every element of an iterator.

fn main() {
    ['a', 'b', 'c'].iter()
        .for_each(|char| println!("{}", char));
}

What if we want to reverse an array, add an 

to every element, and then collect it into a vector of strings?

fn main() {
    let v: Vec<String> = ['a', 'b', 'c'].iter()
        .rev()
        .map(|char| format!("{}m", char))
        .collect();
        
    println!("{:?}", v); // ["cm", "bm", "am"]
}

What if we want to get the product of numbers from 1 to 5 (not inclusive)? 

 lets us apply a function to the first and second elements, then to the result and the third element, and so on.

fn main() {
    let product = (1..5).fold(1, |a, b| a * b);

    println!("{}", product); // 24
}

Hopefully, this gives you a taste of the power of iterators. They're not just for looping over them; they're a convenient and powerful tool for transforming data. The best way to learn about all those methods is to browse the 

 documentation. That's also where you can learn to implement custom iterators - all you need to do is implement the trait on your own type.

Rust allows pattern matching and all the de-structuring goodness associated with it. An underscore (

) is used as a catch-all - it matches anything.

fn main() {
    println!("What can you catch but never throw?");
    
    // (Pretend to) read the user's answer.
    let user_input = "a flu";
    println!("You answered: {}", user_input);
    
    // Verify user's answer!
    match user_input {
        "a cold" => println!("Correct!"),
        "a flu"  => println!("Good enough!"),
        _        => println!("You lose :("),
    }
}

Tuples can be de-structured while we're pattern-matching against them. Underscores can also be used inside those patterns. Here's an implementation of 

fn main() {
    for i in 1..20 {
        let remainders = (i % 3, i % 5);

        match remainders {
            (0, 0) => println!("fizzbuzz"),
            (0, _) => println!("fizz"),
            (_, 0) => println!("buzz"),
            (_, _) => println!("{}", i),
        }
    }
}

Enums can be neatly de-structured too. Instead of matching specific values inside of structures, they can be captured in a variable.

enum Stuff {
    Foo,
    Bar(f64),
    Baz,
    Bazz,
}

fn main() {
    let stuff = Stuff::Bar(4.4);
    
    match stuff {
        Stuff::Foo    => println!("It's a foo!"),
        Stuff::Bar(x) => println!("It's a bar that contains {}", x),
        _             => println!("It's something else."),
    }
}

Traits essentially declare some functionality that concrete types may provide. Traits can be compared to interfaces in other languages or (more accurately) to typeclasses in Haskell. They are Rust's solution to the problem of code reuse. They can pretty much act as abstract types, too.

// Trait definition.
trait Meow {
    fn meow(&self);
}

struct Cat;

// Trait implementation for Cat.
impl Meow for Cat {
    // The signature here has to be the same as in the trait definition.
    fn meow(&self) {
        println!("Cat goes meow!");
    }
}

fn main() {
    let cat = Cat;
    cat.meow();
}

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

The Future Of Software Engineering

Tutorials on Traits

What Rust Is All About: A Small Tour

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript