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();
}

AUTHOR

Tomasz Kurcz

What Rust Is All About: A Small Tour

Prelude to Vectors in the Rust Programming Language

In this post, we are going to explore in detail how to work with resizable arrays in Rust. Specifically, we will take a closer look at the Vector type, its syntax, and some use cases like filtering and transforming a collection.

In software development, we often face the need to deal with a list of objects or values. For example, enumerating words or ingesting series of numeric values, parsing structured data from tables or data storage like CSV files or a database.

Also referred to as collections, such data structures serve as a container of discrete values, offering a great facility to organise all kinds of dynamic data in a program. The Rust Standard Library includes several different kinds of collections like static arrays, tuples, vectors, strings and hashmaps. 

Our focus here is set on one of the more commonly used array-like types - the 

 type. Unlike arrays and tuples, collections of type 

 are dynamic which means they can be changed at runtime, making them a versatile and convenient data type.

In this post, we are going to explore the following aspects of the 

Finally, we are going to take a moment to review how Rust’s internal safety mechanisms protect the developer from performing potentially unsafe operations.

This tutorial assumes you are familiar with the Rust language syntax and have a general understanding of how a program allocates memory (e.g. heap vs stack).

We often use terms like collections and arrays to describe structures of numbered lists of items. The vector type in Rust is one example of such a structure and it is the most commonly used form of collection. It has the type 

The basic structure of a vector can be seen as a combination of the following information:

A vector can always be represented as a tripled of these 3 values: pointer, capacity, and length.

 type allows us to make use of several guarantees provided by the Rust runtime.

For example, the pointer of a vector can never be 

 type is null pointer optimized. If a vector is empty (contains no elements) or all elements are zero-sized, then Rust ensures that no memory will be allocated for the vector.

 of a vector indicates the number of elements that can be added to a vector without re-allocation of memory. It can be seen as a sort of reserved or pre-allocated memory.

You can learn more about the guarantees and memory specifics of the vector type 

There are several ways we can define a new vector. 

 function which returns a new empty vector. Once created, the new vector variable can be marked as mutable (using the 

 keyword) in order to be able to add and remove elements from it. 

let mut vec = Vec::new();
vec.push("one");
vec.push("more");
vec.push("thing");
println!("{:?}", vec);

It is worth pointing out that we did not declare the type of elements we intend to add to the collection. Let's see what happens if we declare the vector as we did above, but don't insert any elements to it e.g.:

This statement alone will not compile and the error message will be 

 type uses generics in order to specify the type of elements that will be added to the vector collection.

In the first example, we added elements to the vector and so the Rust compiler was able to infer the type of the variable 

 as the elements being added to it are of type 

In the second example, only initializing a new empty vector was not enough for the Rust compiler to determine what kind of elements we intend to store this causing raising a compiler error.

In order to solve this, we can choose to explicitly specify the type of the vector collection during initialization. For example:

 function may seem a bit verbose as we first need to initialize a mutable variable and only then add elements to it.

 macro which adds certain facilities to make it easier to initialize new vectors by also providing the initial elements in the collection.

We could rewrite our example in order to use the 

let mut vec = vec![];
vec.push("one");
vec.push("more");
vec.push("thing");
println!("{:?}", vec);

Since the initial elements of the vector are known upfront, this can be made even more concise, by directly initializing the vector with the initial elements:

let vec = vec!["one", "more", "thing"];
println!("{:?}", vec);

Now that we know how to create a vector, let's have a look at some of the techniques we can utilize in order to access the contents (or elements) of a vector.

 of the vector corresponds to the number of elements currently being stored by the vector. We can obtain the length using the 

let vec = vec!["one", "more", "thing"];
println!("There are {:?} elements.", vec.len()); // 3

 of the vector is the number of elements that a vector can hold without the need to reallocate additional memory. 

A vector normally stores its elements in a memory buffer which can grow over time as new elements are being added to it. By default, the capacity of the vector is automatically adjusted as we add elements to the collection. 

When we create a new empty vector, we can choose to define an initial capacity, essentially reserving the initial buffer size of the vector. This means that when new elements are added, the vector will not have to reallocate additional memory as long as there is remaining space in its buffer (capacity).

let vec: Vec<&str> = vec![];
println!("Capacity {}, currently holding {} elements.", vec.capacity(), vec.len()); // capacity 0, elements 0

If we just create a new empty vector, it has 0 elements and a capacity of 0.

This means adding an element will require the vector to first allocate some memory to increase its capacity to at least 1, in order to accommodate the incoming element.

let mut vec: Vec<&str> = vec![];
vec.push("one");
println!("Capacity {}, currently holding {} elements.", vec.capacity(), vec.len()); // capacity 1, elements 1

Of course, this works just fine and may not be a problem at all.

For example, we can create a new empty vector with an initial capacity for 10 elements:

let vec: Vec<i32> = Vec::with_capacity(10);
println!("Capacity {}, currently holding {} elements.", vec.capacity(), vec.len()); // capacity 10, elements 0

Accessing specific values within a vector

 trait, allowing us to directly access elements by index:

let vec = vec!["one", "more", "thing"];
let result = vec[0];
println!("{}", result); // "one"

A common source of bugs and security vulnerabilities is what is commonly known as out of bounds access i.e. trying to access an element outside the length of a vector.

While very easy to use, direct access by index has a downside - we may accidentally request an element index which is out of bounds which will cause the program to panic:

let vec = vec!["one", "more", "thing"];
let result = vec[3];
println!("{}", result);

thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 3'

To help with that, Rust offers an alternative using the 

 instead, allowing us to gracefully handle this scenario and as a result, improving the reliability of the program:

A mutable vector can be changed by adding or removing elements from it. We do this using the 

 functions. Respectively they either append an element to the end of a vector or remove the last element of a vector.

 value which either holds the removed element or 

 if no elements were removed from the vector (e.g. when it was already empty).

let mut vec = vec!["one", "more", "thing"];
vec.push("!");
println!("{:?}", vec); // ["one", "more", "thing", "!"]
let removed_el = vec.pop(); // "!"
println!("{:?}", vec); // ["one", "more", "thing"]

In some situations it may be useful to update an element which already belongs to a vector:

let mut vec = vec!["one", "more", "thing"];
vec[0] = "two";
vec[2] = "things";
println!("{:?}", vec); // ["two", "more", "things"]

You may notice that we are directly accessing an element by index. Like we saw earlier, given an index outside the bounds of the vector the application will panic.

We can use a technique we showed earlier with the 

 which returns a mutable reference to an element, if it exists. We can then rewrite the above example in a safer way as follows:

let mut vec = vec!["one", "more", "thing"];
if let Some(first_word) = vec.get_mut(0) {
    *first_word = "two";
}
if let Some(third_word) = vec.get_mut(2) {
    *third_word = "things";
}
println!("{:?}", vec);

 with a reference to the element at the given index. If the element doesn't exist (when the index is out of bounds), 

 returns a mutable reference which we can use to update the value.

If we would like to perform a certain operation over each element in a vector, we can iterate through all elements rather than accessing them one at a time. One way would be to use a 

let vec: Vec<&str> = vec!["one", "more", "thing"];
for word in vec {
    println!("{:?}", word);
}

In this case, we are consuming the vector by executing the operation defined in the for loop block over each element of that vector.

We could also limit the operation to just references to the elements of the collection.

let vec: Vec<&str> = vec!["one", "more", "thing"];
for word in &vec {
    println!("{:?}", word); // word is now of type &&str
}

Using the same technique, we can obtain a mutable reference to the elements, allowing us to affect changes to the collection:

let mut vec: Vec<&str> = vec!["one", "more", "thing"];
for word in &mut vec {
    if word == &"one" {
        *word = "two";
    }
    if word == &"thing" {
        *word = "things";
    }
}
println!("{:?}", vec); // ["two", "more", "things"]

Konstantin Kostov

The Rust Map Function - A Gateway to Iterators

This post looks at the Map function in the Rust programming language as one of the basic tools to use and interact with collections and iterators.

Arguably one of the main reasons the Rust language has become so popular is because the entire ecosystem builds upon a consistent experience. From toolchains to documentation and language specifications, almost every aspect of the language adheres to a certain level of consistency. Getting into the Rust mindset allows us, developers, to intuitively discover aspects of the language and gain the ability to write better and more consistent code.

In this article, we are going to focus on Iterators - one of the key language tools enabling us to write idiomatic Rust code. This may surprise you at first, especially if you are coming from other programming languages (for example Swift or JavaScript), where working with types like lists and arrays does not immediately expose the concept of Iterators. The opposite is valid for Rust. Iterators cover a very large number of applications and as such, being comfortable with their use greatly facilitates becoming a better Rust developer.

In order to follow along, you will need at least some familiarity with the Rust programming language. To make things easier, this article includes detailed code samples and links to the Rust playground where you can execute and study the provided code snippets. 

After reading this article, you will know:

A core concept for Functional programming, Map is also commonly used as a tool for dealing with lists and collections in Rust and is one of the most essential methods for working with Iterators.

 method offers a way to apply a function (or a closure) on each element from a list. This is key in functional programming methodologies and offers a way to transform a collection of type A, to a collection of elements of type B. In Rust, the 

 method is frequently used to interact with 

 and any other types which can be represented as an 

Let's illustrate this with an example. Imagine a list of numbers (a vector of numbers) and we would like to multiply each number by 10.

let numbers = vec![3, 6, 9, 12];
let result: Vec<i32> = numbers
    .iter()
    .map(|n| n * 10)
    .collect();
// result is now [30, 60, 90, 120]

 doesn't work directly on the vector of numbers.

The answer lies with the fact Rust makes it very easy to use iterators for almost everything. In the ergonomics of the language, it is generally preferred to use iterators instead of directly interacting with a vector. 

In the example above we actually have two iterators at play - the first which we obtain through the use of 

 in order to get the elements of the vector and a second one which happens to be the return type of the 

This may be a bit surprising at first, especially if you have a background in other programming languages (for example Swift or JavaScript) but indeed, in Rust 

 also returns an iterator. Let's have a closer look at the syntax we need in order to use Map.

, we can find the exact signature of the Map method:

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B

With this we can focus on several key takeaways.

 can only be applied to iterators. This means that we first need to convert a collection type to an iterator before we can transform its elements.

To obtain an iterator from a vector, the standard library provides 

let str_numbers: Vec<&str> = vec!["1", "2", "3", "4"];
let str_numbers_iterator = str_numbers.iter();

 is also an iterator. This can be very useful in cases when multiple transformations need to be chained one after the other. 

Let's illustrate this by extending the example with a second transformation of the vector of numbers. After multiplying by 10, let's divide each element by 3:

let numbers = vec![3, 6, 9, 12];
let result: Vec<i32> = numbers
    .iter()
    .map(|n| n * 10)
    .map(|n| n / 3)
    .collect();
// result is now [10, 20, 30, 40]

Since the Map function returns an Iterator, the result of the first transformation 

 will be used as input for the second transformation 

You probably notice by now that despite the return type of Map being Iterator, we somehow manage to get back a vector of results. 

Learn

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

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Tutorials on Functional Programming

What Rust Is All About: A Small Tour

Prelude to Vectors in the Rust Programming Language

This has been a really good investment!

Advance your career with newline Pro.

The Rust Map Function - A Gateway to Iterators

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript