# Part 1: Variable and DataTypes in Rust

Variables are the basic building blocks of a programming language. It holds data in the computer memory during runtime. The data that a variable hold can be different types. Like other languages, Rust has 2 kinds of high-level data types. `Scalar` and `Compound` . `Scalar` contains a single value whereas `Compound` holds multi-value data in the memory during run time. the default data types are explained in the figure below:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1675492541361/64f606bc-3820-446f-b947-353e18a2b086.png align="center")

Now if you mark in the figure we use `let` keyword to declare a variable and the value of the variable is on the right side of the `=` symbol.

> It is important to note that the variable in the rust is immutable (do not change the data once loaded) by default (why? please refer the part:0 of this series) However you can have the liberty to make it immutable by adding a `mut` keyword in front of any variable name. Example below

```rust
let x = 10 ; //this immutable 
let x = 11 ; // while doing this you will get an error
mut let x = 10 ; //this is mutable
let x = 11 ; // you are safe to do this action
```

it is best practice to mention the data type of the variable while declaring. However, rust can automatically detect when you have `rust analyzer` installed on any of the popular IDE. To mention the data type below are the samples.

```rust
let a: u32 = 23; // a unsigned 32 bit integer
let b: f32 = 2.3; // a floating point 32 integer
let c: bool = false; // a boolean type variable
let d: char = 'm'; // a char type variable
let e: (i32, char, f32) = (23, 'm', 2.3); // a tupple type
let f: [i32; 5] = [6, 7, 8, 9, 10]; // an array type
```

To know what all are the different types of integers and floats please refer [here](https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types).

to print anything to the output console rust used `println!()` macro. in side `println!()` macro to extract the value of a variable you have to enclose the variable with `{}`. the sample is given below:

```rust
fn main() {
    let mut a: i32 = 7; // a mutable variable
    println!("The value of a is: {a}"); //print 7
    let a = 8;
    println!("The value of y is: {a}"); //print 8
}
```

let's know something more about Compound data types:

**Array operations:**

let's take an array as :

```rust
let f: [i32; 5] = [6, 7, 8, 9, 10];// i32 is the data types of the array and 5 is the length of the array.
let first = f[0]; // first holds First element of array 
let five = f[4]; // holds 5th element of the array
let r = &f[0..3]; // r holds the element starting with 0th index till 2nd index. last index is always excluded.
let g: [i32; 0] = [] // an empty array.
let g: [i32; 5] = [7, 5] // returns [7, 7, 7, 7, 7] 
```

**Tuple operations:**

let's take a tuple as:

```rust
let f: (i32, &str, f64)= (7, "samir", 3.8); // a tuple
let mut r = f.0; //r contains the 0th index value i,e 7
let r = f.2; // now r contains the 2nd index value i,e 3.8
```

In this part, we learnt the overview and a few operations on array and tuple. this is very easy and if you have learnt any programming language earlier this might be familiar to you. but as I told this series is for the beginner and comes in handy during the initial days.

Thank you for hopping in and see you in the next part.