Gain insights into Rust for real-world data, delving into data input, storage, analysis, and visualization. Explore web scraping, SQL, NoSQL databases, and machine learning with Rust.

rust-data-0.1.18.tar.gz

rust-basic

rust-basic-live

rust-basic-live-copy

Rust is a fast-growing, modern programming language oriented to system programming that guarantees memory and thread safety. It enables you to eliminate many classes of bugs at compile-time. This course covers all the skills needed to work with real-world data using Rust. 

In this course, you’ll learn all the basics of intermediate Rust programming. You’ll discover and master the five data-related skills: data input, storage, serving data, analyzing data, and data visualization. You’ll learn to ingest data from various formats, like CSV, JSON, web APIs, and web scraping. You’ll also learn to store the data using Redis, an SQL server, or a NoSQL database like MongoDB. Finally, you will learn how to present your data in meaningful visualizations, web maps, and reports. 

After taking this course, you’ll be able to approach data using Rust with confidence. You’ll be able to manage SQLite, ORM SQL, and NoSQL databases in Rust. You’ll learn the basics of web scraping, data analysis, and machine learning in Rust.

Processing Real-world Data Efficiently with Rust

Let’s quickly review what arrays and slices are.

# Arrays

An **array** is a collection of a fixed number of elements of any single type `T`. The array type is `[T, n]`, where `T` is any type, and `n` is the fixed number of elements. That is, the array’s size, which is known at compile time.

There are two ways to create arrays:


- By listing each element (such as `[A, B, C]`, where `A`, `B`, and `C` are elements of the same type).

- By copy-repetitions, which  is declaring an element and the number of copies to do of that element (such as `[A; 3]`). The element type must implement the `Copy` trait.


Here are some examples of array instantiation:

```rust
let array [f32; 3]= [1.1, 1.2, 1.3];
let array = [0i8; 3];
```

Arrays are 0-indexed. The first element is at index `0` and the elements are retrieved with a `usize` indexing notation. We can also assign values to elements of an array using the same notation, provided the array is `mut`.



let array = ["first", "second", "third"];
println!("Element 0 is: {}", array[0]);

let mut new_array: [i32; 4] = [0; 4];
new_array[1] = 1;
println!("Element 1 is: {}", new_array[1]);

We can print arrays with `Debug`.

In fact, the compiler assigns a `Debug` and a `Default` notation for arrays with up to 32 elements.

The following code works like we expect it to:


let array = [0i8; 32];
println!("{:?}", array);

However, the following code will not compile:

// Careful: this will not compile!
let array = [0i8; 33];
println!("{:?}", array);

If we run the code above, it will show the following compiler error:

```
error[E0277]: arrays only have std trait implementations for lengths 0..=32
```

The `Default` trait is also automatically implemented for arrays with up to 32 elements.

# Slices

A **slice** is a type which lacks ownership. Slices are used to reference a contiguous sequence of elements in a collection.

Arrays naturally coalesce into a slice.

The canonical form for a slice is &array[slice], which will get a slice out of a whole collection.

For example:


let array = [1, 2, 3, 4, 5];
let slice = &array[1..3];
println!("Slice: {:?}", slice);

If we run the code above, we get:

```
Slice: [2, 3]
```
This means the slice indexes with the first element included and the second excluded.

Let’s check the behavior of the code below:


Contrary to what we expected to happen, `&array[..3];` prints:


```
Slice: [1, 2, 3]
```
On the other hand, `&array[5..];` prints:
```
Slice: [6, 7, 8, 9, 10]
```

This seems counterintuitive until we remember that indexing is `0` based.
In fact, the last code example produces an empty array because we have asked for a slice containing all previous elements of element `0`.

We need to remember that slices lack ownership, which is why we can keep creating overlapping slices within the same array.

If slices had ownership, they could not be used as easily to access arrays.


# Common array errors

People who are fluent in other programming languages (especially C/C++ or Python) may have some trouble getting used to looping in Rust.
Let’s consider the following code:


// careful: it will not compile!
let magic_choice = [0, 1, 2];
let magic_answer = ["first", "second", "third"];

for i in magic_choice {
  println!("{}", magic_answer[i]);
}


Conceptually, this process is not that complicated. We use an array of `magic_choice` (or indexes) to get the elements of `magic_answer` (our target array).

We can find this same construct in many different scenarios, such as when we leave the choice of the array up to the user.

Here, however, we get an error:


```
error[E0277]: `[{integer}; 3]` is not an iterator
```
What went wrong?

As it often does, the compiler comes to our rescue with a suggestion:

```
borrow the array with `&` or call `.iter()` on it to iterate over it
```
Nice! Let’s try to iterate over the array:


// careful: it will not compile!
let magic_choice = [0, 1, 2];
let magic_answer = ["first", "second", "third"];

for i in magic_choice.iter()  {
  println!("{}", magic_answer[i]);
}


The code above will not compile and will return the following error:


```
error[E0277]: the type `[&str]` cannot be indexed by `&{integer}`
```

The compiler inferred the `integer` type for the `magic_choice` array. But arrays are indexed by `usize`.

We could indeed cast the `i` element to a `usize`:

// careful: it will not compile!
let magic_choice = [0, 1, 2];
let magic_answer = ["first", "second", "third"];

for i in magic_choice.iter()  {
  println!("{}", magic_answer[i as usize]);
}


However, we still have a faulty code. The code above returns this error instead of compiling:

```
error[E0606]: casting `&i32` as `usize` is invalid
```
Once again, the compiler provides a helpful suggestion:

```
cannot cast `&i32` as `usize`
help: dereference the expression: `*i`
```

With this information, we can correct the code to the following, which will finally compile:


// This will compile!
let magic_choice = [0, 1, 2];
let magic_answer = ["first", "second", "third"];

for i in magic_choice.iter() {
  println!("{}", magic_answer[*i as usize]);
}


Many new rustaceans (Rust programmers) find themselves wrestling with the compiler. There’s nothing wrong with this process, as long as we try to understand the errors we are making at each step.

Now that our code works correctly, let’s look back at the errors we made:

- We looped the wrong way (without `.iter()`)
- We didn't index with `usize`
- We cast the wrong way
- We didn't dereference properly

These problems started because the compiler inferred that `magic_choice` was an `integer` array.


The example above is useful for two reasons:

1. It shows a way to correct the code as we go, with the help of the compiler.
1. It demonstrates how setting everything to the wrong kind of integer can cause an error. People who are already comfortable with other programming languages often make this mistake.


Another common error that programmers make is trying to impose the type of the data in Rust. That happens because  if we are used to setting indexes with integers in C or other similar languages, we usually loop with `int`.

Funnily enough, we could have made the compiler infer the right type from the beginning, like this:


// This will compile!
let magic_choice = [0, 1, 2];
let magic_answer = ["first", "second", "third"];

for i in magic_choice.iter() {
  println!("{}", magic_answer[*i]);
}


If we had just dereferenced without casting, the compiler would have understood that we meant to have an array of `usize`.

Casting everything is common in C/C++. People with a strong background in C often try to cast everything, hoping to make the compiler understand what they are trying to accomplish.

However, these extra steps are completely unnecessary if we explain what the initial data is to the compiler before using it, rather than casting after the compiler has inferred the wrong type.

In fact, we could have been explicit right from the beginning!

Check out the following code:


// This will compile!
let magic_choice: [usize; 3] = [0, 1, 2];
let magic_answer = ["first", "second", "third"];

for i in magic_choice.iter() {
  println!("{}", magic_answer[*i]);
}


In this case, we declared the right type at the beginning, and everything went smoothly afterward.

# The slice pattern

One of the most useful constructs of Rust is its ability to match patterns.
 
However, we can also match using a slice pattern!

The slice pattern extracts elements out of an array:


let point = [1.22, 3.3];
let [x, y] = point;
println!("X: {}", x);
println!("Y: {}", y);

But how can we apply this process to slice pattern matching?

Let’s consider the following code:


fn print_elements(elements: Vec<&str>) {
  match elements.as_slice(){
    [] => println!("No elements"),
    [element] => println!("One element only: {}", element),
    _ => println!("More than one element present"),
  }
}

print_elements(vec![]);
print_elements(vec!["one"]);
print_elements(vec!["one", "two"]);

In the code above, we match against a vector of `&str` as if it was a slice (`as_slice()`).


> **Note**: The following lesson assumes that you are already familiar with vectors.

Let’s break down how our example code works:

- The first arm of the `match` is an empty slice, so it matches against empty vectors.
- The second arm is a slice pattern with one element. It extracts and prints other such elements.
- The third arm matches against any vector with more than one element.

Consider this modification of the code:



fn print_elements(elements: Vec<&str>) {
  match elements.as_slice(){
    [] => println!("No elements"),
    [element] => println!("One element only: {}", element),
    [element1, element2] => println!("Two elements\n1: {}\n2: {}", element1, element2),
    _ => println!("More than one element present"),
  }
}

let empty = vec![];
let one = vec!["one"];
let two = vec!["one", "two"];
let three = vec!["one", "two", "three"];

print_elements(empty);
print_elements(one);
print_elements(three);
print_elements(two);

As you can see, we can make a lot of progress just by simplifying complex matches with the right slice pattern.


Learn about the most common data types and accessing patterns in Rust.

Before We Begin

Rust Data Structures

Rust Data Structures

Basics of Functional Programming

Functional Programming in Rust

Data Skill: Input Data

Input Data with Rust

Web Scraping: Getting Products and Prices from an E-commerce Site

Data Skill: Store Data

Storing Data in Rust

Create a Simple Payroll Management System

Data Skill: Serve Data

Serving Data in Rust

Build a Server Backed Up by a Database

Data Skill: Analyze Data

Assessment on Analyze Data

ML Basics: Classification of the Iris Data Set

Machine Learning and the MNIST Digit DataSet

Data Skill: Dataviz and Storytelling

Data Viz and Storytelling in Rust

Create Infographics in Rust

Some Parting Words

Arrays and Slices