Scalar Datatypes in Rust

All initialized variables use data-type during declaration to restrict the type of data to be stored. Therefore, we can say that data types are used to tell the variables the type of data they can store. 

In this article, we will specifically talk about the Scalar Data types in the Rust programming language. A Scalar type in Rust represents a single value. For example, an int data type only stores single integer data and not multiple integers nor a combination of different data types.

Rust has four primary scalar types: 

• Integers
• Floating-point numbers
• Boolean
• Characters

Let’s discuss them in detail.

Integer types

Integers are everywhere, Integer is a whole number with a sign and without a fractional part. For example 1, 5, -9, 200001, -15489752are integers

Integers are one of the primitive data types in Rust, Rust compiler can automatically detect Integers and also the programmer can explicitly define integer type. 

Example:

Rust

fn main() {

      // implicitly defining int
    let x = 6;

      // explicitly defining unsigned int
    let y: u16 = 9;

      // explicitly defining signed int
    let z: i16 = -7;
    println!("{} {} {}", x,y,z);
}

Output:

6 9 -7

In Rust, integer declaration indicates that the value it’s associated with should be an unsigned integer that starts with u (or) signed integer types start with i and takes up 32 bits of space with a minimum of 8 bits.

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

The signed complement integers types have:

Type	Minimum	Maximum
i8	-(27)	27 – 1
i16	-(215)	215 – 1
i32	-(231)	231 – 1
i64	-(263)	263 – 1
i128	-(2127)	2127 – 1

Floating-point types

Floating-point numbers integers with the decimal parts. For example 3.22, -5.89, 200.0000. Rust also has a primitive datatype for floating numbers. Rust’s floating-point types are either f32 and f64, which are 32 bits and 64 bits in size, respectively. Like Integers, you can both explicitly and implicitly define floating-point numbers. Syntax of floating-point numbers

Rust

fn main() {
// implicit floating number type
let x = 200.000;
// explicitly floating point type
let y: f64 = 9.894;
let z: f64 = -7.4;
println!("{} {} {}", x,y,z);
}

Output

200 9.894 -7.4

Boolean types

Boolean type is one of the built-in data types provided by Rust, which are defined by the True or False keywords. Generally, it is used to represent the truth values of the expressions. Boolean types in Rust are provided with 1-bit memory. The Boolean type in Rust is specified using the bool keyword.

Rust

fn main() {
// true boolean
let x: bool = true;
// false boolean
let y: bool = false;
println!("{} {}", x,y);
}

Output:

true false

Character types

The character data type is used for storing characters. The keyword used for the character data type is char. Characters typically require 1 byte of memory space and range from -128 to 127 or 0 to 255. 

Example:

Rust

fn main() {
    let s = 'z';
    let c = 'ℤ';
      println!("{} {}", s,c);
}

Output

z ℤ

Simple Rust program with all scalar datatypes:

Rust

fn main() {

        // Default is "i32"
        let g = 9;
        println!("{}", g);

        // Default is "f64"
        let f = 2.9;
        println!("{}", f);

        // Add explicit type
        let e: i64 = 14122020;
        println!("{}", e);

        // Boolean
        let is_active: bool = true;
        println!("{}", is_active);

        // char
        let c = 'a';
        println!("{}", c);
        let face = '\u{1F600}';
        println!("{}", face);
}

Output:

9
2.9
14122020
true
a
????