DEV Community: Silva

Back to Basics With Rust: Part 2

Silva — Tue, 02 Aug 2022 18:03:12 +0000

Continuing from part one. I think you now put more thought in declaration. When writing code, It's also good to understand the terminologies and classifications because, that does not change much when moving from one programming language to another. In this article I continue going into detail about declaring of variables (using comment lines starting from 1 to 7) and also classifying them. By classifying I mean talking about primitive types. Primitive data types are divided into two, scalar and compound types.

Looking at comment line no. 1 : The declared variables below are example of scalar types.
- Scalar type represents a single value. e.g char, integers, floating points and boolean.
Comment Line no. 2 to 7 are examples of compound types.
- Compound types represents multiple values. e.g array and tuples.

fn main() {
    // Scalar -----------------------------------------  1 
    let s_char : char = 's';
    let is_bool : bool = true;

    // Compound ---------------------------------------- 2
    let mut array: [i32; 3] = [0; 3]; // --------------- 3
    array[0] = 1; // ----------------------------------- 4
    let array: [i32; 3] = [0, 1, 2]; // ---------------- 5

    let (tu, ple): (i32, char) = (32, 'a'); //---------- 6
    let tuple: (i32, char) = (32, 'a'); //-------------- 7
}

Declaring compound types:

Comment line no. 3 and 5 are Arrays

Arrays are fixed size collection of values with similar types.
Once declared can not grow.
Comment no. 3 above:
- [i3; 3] indicate that the array will be of type i32, with the size of 3 (size is always a positive value).
- [0; 3] is similar to [x; N] is called a repeat expression, which will produces an array of [0, 0, 0]
- mut mean the array is mutable. which allows the value inside an array to be changed or replaced.
comment no. 4 :
- 0 inside array[0] indicates the index, index starts from 0, end at [length - 1].
- e.g array [0, 0, 0] index will start from 0 and end at 2
- specifying a bigger index like array[4] can result to index out of bounds: the len is 3 but the index is 4
Looking at comment no. 5 and 3, they are almost identical, both are declared as [i32; 3]
the only different is that comment no. 5 has a collection of integers i.e., [0, 1, 2], not a repeat expression.
also notice 3 and 5 have the same name(both called array). that concept is called Shadowing.

Shadowing

is to declare a new variable with the same name as a previous variable as shown in 3 and 5
the compiler will ignore the first variable meaning if we try array[0] = 1; below comment no. 5, get the below error :
```
error[E0594]: cannot assign to `array[_]`, as `array` is not declared as mutable
```
`
Why use shadowing ?
- for beautiful code, instead of using array_one and array_two (some might disagree).
- for casting, if you want to change types.
- When you have multiples scopes or closures, shadowing can be useful (will get into details in the future).

Comment line no 6 and 7: are Tuples

A tuple is defined as a collection of values that consists of different or similar types (tuples are heterogeneous).
tuples have a length, looking at comment no. 6 and 7 the length of the tuple is 2
tuples also have a sequence.
- comment no. 6 tu is the first sequence and ple is the second sequence
- comment no. 7 when calling the first sequence, we use tuple.0

Visiting the rust doc will help you get more information on primitives types such as never which i didn't tackle.

Back to Basics With Rust: Part 1

Silva — Wed, 06 Jul 2022 18:55:57 +0000

The first few lines of code are usually declaration. let num = 0. Most of the time you don't put too much thought on which integer type to choose or indicate, it's like you are on autopilot. When declaring a variable let num = 0;, you expect the compiler to add the type, and also indicate that the variable is immutable. Lets switch off auto pilot and understand what let num: i32 = 1; mean.

By default as stated in the book, variables are immutable.

Immutable means can not be changed (Read-Only).
Mutable, can change (Read and Write).

Coming from other languages if a variable can't change, you might think of a constant (const). The difference between constant and immutable variable:

    const SEVEN: i32 = 7; // constant
    let seven = 7; // immutable variable
    let mut six = 6; // mutable variable

Constant

const needs to have an SNAKE_CASE uppercase name, else you get a warning constant `seven` should have an upper case name .
const needs you to specify the type(see error below).
const will never be mutable, meaning you can't add the mut keyword.

error: missing type for `const` item
 --> src/main.rs:1:7
  |
1 | const SEVEN = 7;
  |       ^^^^^ help: provide a type for the constant: `SEVEN: i32`

Immutable

You are not forced to specify the type, if you omit the type the compiler will assist.
immutable can be converted to mutable by adding the mut keyword.
Looking at the rust naming conversion, the variable is always snake_case lowercase.

A constant needs you to always specify a type, be it integers or tuples even arrays. Looking at integers, there are multiple types, such as i8, u32, etc.

Before choosing an integer, you need to understand that Rust has signed i and unsigned u types.

Signed i types accept both positive(+) and negative(-) values, depending on the bits you selected.
Unsigned u only accepts positive(+) values.

Next to i or u are the bits, so 8-bits, 32-bits, and etc. The bits indicate the storage capacity e.g u8 stores values from 0 to 255, above that results to the error below.

error: literal out of range for `u8`
 --> src/main.rs:3:17
  |
3 |     let x: u8 = 256;
  |                 ^^^
  |
  = note: `#[deny(overflowing_literals)]` on by default
  = note: the literal `256` does not fit into the type `u8` whose range is `0..=255`

There's also usize and isize, which is dependent on the size of your machine architecture. So if running a 32-bit machine, usize can be u32 (32-bits). There are other types such as floats(f32 and f64), boolean(bool), arrays([1, 2, 3]), and more.