# Primitive data types

* **bool**

  true or false

```rust
let x = true;
let y: bool = false;

// ⭐️ no TRUE, FALSE, 1, 0
```

* **char**

  A single Unicode scalar value

```rust
let x = 'x';
let y = '😎';

// ⭐️ no "x", only single quotes
//because of Unicode support, char is not a single byte, but four.
```

* **i8, i16, i32, i64**

  Fixed size(bit) signed(+/-) integer types

| DATA TYPE | MIN                  | MAX                 |
| --------- | -------------------- | ------------------- |
| i8        | -128                 | 127                 |
| i16       | -32768               | 32767               |
| i32       | -2147483648          | 2147483647          |
| i64       | -9223372036854775808 | 9223372036854775807 |

💡 Min and max values are based on IEEE standard for Binary Floating-Point Arithmetic; From **-2ⁿ⁻¹ to 2ⁿ⁻¹-1** . You can use **min\_value()** and **max\_value()** to find min and max of each integer type, ex. i8::min\_value();

* **u8, u16, u32, u64**

  Fixed size(bit) unsigned(+) integer types

| DATA TYPE | MIN | MAX                  |
| --------- | --- | -------------------- |
| u8        | 0   | 255                  |
| u16       | 0   | 65535                |
| u32       | 0   | 4294967295           |
| u64       | 0   | 18446744073709551615 |

💡 Same as signed numbers, min and max values are based on IEEE standard for Binary Floating-Point Arithmetic; From **0 to 2ⁿ-1** . Same way you can use **min\_value()** and **max\_value()** to find min and max of each integer type, ex. u8::max\_value();

* **isize**

  Variable sized signed(+/-) integer

Simply this is the data type to cover all signed integer types but memory allocates according to the size of a pointer. Min and max values are similar to i64 .

* **usize**

  Variable sized unsigned(+) integer

Simply this is the data type to cover all unsigned integer types but memory allocates according to the size of a pointer. Min and max values are similar to u64.

* **f32**

  32-bit floating point

Similar to float in other languages, **Single precision**.

💡 Should avoid using this unless you need to reduce memory consumption badly or if you are doing low-level optimization, when targeted hardware not supports for double-precision or when single-precision is faster than double-precision on it.

* **f64**

  64-bit floating point

Similar to double in other languages, **Double precision**.

* **arrays**

  Fixed size list of elements of same data type

```rust
let a = [1, 2, 3]; // a[0] = 1, a[1] = 2, a[2] = 3
let mut b = [1, 2, 3];

let c: [i32; 0] = []; //[Type; NO of elements] -> [] /empty array
let d: [i32; 3] = [1, 2, 3];

let e = ["my value"; 3]; //["my value", "my value", "my value"];

println!("{:?}", a); //[1, 2, 3]
println!("{:#?}", a);
//  [
//      1,
//      2,
//      3
//  ]
```

⭐️ Arrays are **immutable** by default and also **even with mut, its element count can not be changed**.

> 🔎 If you are looking for a dynamic/growable array, you can use **Vec**. Vectors can contain any type of elements but all elements must be in the same data type.

* **tuples**

  Fixed size ordered list of elements of different(or same) data types

```rust
let a = (1, 1.5, true, 'a', "Hello, world!");
// a.0 = 1, a.1 = 1.5, a.2 = true, a.3 = 'a', a.4 = "Hello, world!"

let b: (i32, f64) = (1, 1.5);

let (c, d) = b; // c = 1, d = 1.5
let (e, _, _, _, f) = a; //e = 1, f = "Hello, world!", _ indicates not interested of that item

let g = (0,); //single-element tuple

let h = (b, (2, 4), 5); //((1, 1.5), (2, 4), 5)

println!("{:?}", a); //(1, 1.5, true, 'a', "Hello, world!")
```

⭐️ Tuples are also **immutable** by default and **even with mut, its element count can not be changed. Also if you want to change an element’s value, new value should have the same data type of previous value**.

* **slice**

  Dynamically-sized reference to another data structure

Think you want to get/pass a part of an array or any other data structure. Instead of copy it to another array (or same data structure), Rust allows to create a view/reference to access only that part of data. And it can be mutable or not.

```rust
let a: [i32; 4] = [1, 2, 3, 4];//Parent Array

let b: &[i32] = &a; //Slicing whole array
let c = &a[0..4]; // From 0th position to 4th(excluding)
let d = &a[..]; //Slicing whole array

let e = &a[1..3]; //[2, 3]
let f = &a[1..]; //[2, 3, 4]
let g = &a[..3]; //[1, 2, 3]
```

* **str**

  Unsized UTF-8 sequence of Unicode string slices

```rust
let a = "Hello, world."; //a: &'static str
let b: &str = "こんにちは, 世界!";
```

⭐️ It's an **immutable/statically allocated slice** holding an **unknown sized sequence of UTF-8** code points stored in somewhere in memory. **\&str** is used to borrow and assign the whole array to the given variable binding.

> 🔎 A [String](https://doc.rust-lang.org/std/string/struct.String.html) is a **heap**-allocated string. This string is growable, and is also guaranteed to be UTF-8. They are commonly created by converting from a string slice using the **to\_string()** or **String::from()** methods. ex: `“Hello”.to_string();` `String::from("Hello");`

💡 In general, you should use **String** when you need **ownership**, and **\&str** when you just need to **borrow a string**.

* **functions**

  As we discussed on functions section, b is a function pointer, to plus\_one function

```rust
fn plus_one(a: i32) -> i32 {
    a + 1
}

let b: fn(i32) -> i32 = plus_one;
let c = b(5); //6
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://learning-rust.gitbook.io/book/basics/primitive-data-types.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.