This collection contains videos that explore the basic types in Rust, including **Fixed size Integer**, **Pointer sized Integer**, **Boolean**, **Strings**, **Characters**, **Arrays**, **Tuples** and more.

If you're just starting out learning Rust and [wrote your first program](https://egghead.io/courses/write-your-first-program-with-the-rust-language), this collection is the right place to get more familiar with the language!

This lesson explains **Type Inference** in Rust and how it allows the compiler to figure out by itself, what type variables have when they get their values assigned.

There are cases when the compiler cannot infer a value's type through static analysis. In such cases, developers have to provide type annotations explicitly.

Type Inference in Rust

This lesson talks about **Integer** types in Rust and that there are **unsigned** and **signed** integers. 

It also explains how every the type names are composed of "u" and "i", for unsigned and signed respectively, followed by their **with in bits**. So `u8` is an unsigned integer that can store values up to 8 bits (0 - 255).



Integer Types in Rust

In this lesson we take a look at **Floating-Point** values and the `f32` and `f64` types. We'll also look at the different ways of defining and creating values of such types.

Floating-Point Types in Rust

In this lesson we discuss the `bool` type that represents either `true` or `false`.

Bool Type in Rust

This lesson discusses the `char` type in Rust, which holds 32 bit unicode values.

Char Type in Rust

Learn how to represent multiple values of different type using a single type by leveraging the power of tuples in Rust. 

Tuples in Rust

Everything in Rust has a type. Even functions that don't seem to return anything. In such and similar cases, we're dealing with a **Unit Type**. Learn about it in this lesson.

Unit Type in Rust

Learn how to create references in Rust using the borrow-operator `&` and when they are useful. 

For a more thorough explanation of references and their characteristics, check out this blog post: https://blog.thoughtram.io/references-in-rust/

Reference Types in Rust

In this lesson we take a look at Arrays and the different ways of creating them. Arrays in Rust are collections of values of the same type that cannot change in size. In other words, the number of fields (or elements) has to be known at compile time.

Arrays in Rust

In this lesson you'll learn about `Vec<T>`, or **Vectors**. Vectors are like Arrays, a collection of values of the same type, but as opposed to Arrays, Vectors can change in size.

Basic Types in Rust

Instructor

Course Content