Data Types

Rust is statically-typed (like Java), but (unlike Java) it generally infers the types. If many types are possible (like when using parse), then we have to specify the type. With that, let's discuss the various types!

Integers

Many languages have a single integer type. Not Rust! Rust has five different integer types based on the length and whether they are signed (possibly negative) or unsigned (always positive):

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
arch	isize	usize

What should you default to? Probably i32. It's what Rust defaults to and is generally the fastest, even on 64-bit systems.

What can you enter as an integer? Any of the following options!

Number literals	Example
Decimal	98_222
Hex	0xff
Octal	0o77
Binary	0b1111_0000
Byte (u8 only)	b'A'

Floats

Floating point numbers are a bit simpler. There are only two types: f32 and f64. In this case, the Rust default is f64.

let x = 2.0; // f64
let y: f32 = 3.0; // f32

Boolean

Just like most other languages, Rust has a boolean type that has two possible values: true or false.

let t = true;
let f: bool = false;

Characters

char represents a Unicode Scalar Value, which means it can represent more than just A-z. Here's an example:

let c = 'z';
let z = 'ℤ';
let heart_eyed_cat = '😻';

Tuples

A tuple groups together any number of values with random types. Here are some examples

let tup: (i32, f64, u8) = (500, 6.4, 1); // type annotation is optional
let tup = (500, 6.4, 1);
let (x, y, z) = tup; // destructure through pattern matching
let x = tup.0 // or by getting the element at the index!
let y = tup.1
let z = tup.2

What happens if you go out of bounds?

Arrays

Arrays are similar to tuples but every element must have the same type. In Rust, once an array is created, it cannot grow or shrink. Here's an example of a common use for arrays:

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

Unlike tuples, you cannot easily destructure arrays via pattiern matching. But you can get the element at the index like so:

let arr = [1, 2, 3];
let one = arr[0];

Unlike the tuple out-of-bounds message, if you go out of bounds with an array, the message is very clear:

Since the index starts at zero, it must always be one less than the length. So this error message is telling us we are going one too far!