Rust Tutorial : Data Types

Declare a Variable

the Type System represents the different types of values supported by Rust
the Type System checks validity of the supplied values, before they are stored or manipulated by the program
ensures that the code behaves as expected
the Type System further allows for richer code hinting and automated documentation

Rust is a statically typed language
every value in Rust is of a certain data type
the compiler can automatically infer data type of the variable based on the value assigned to it

use the let keyword to declare a variable

fn main() {
   let company_string = "TutorialsPoint";  // string type
   let rating_float = 4.5;                 // float type
   let is_growing_boolean = true;          // boolean type
   let icon_char = "\u{2665}";             // unicode character type

   println!("company name is:{}",company_string);
   println!("company rating on 5 is:{}",rating_float);
   println!("company is growing :{}",is_growing_boolean);
   println!("company icon is:{}",icon_char);
}

the println! macro can take two arguments

a special syntax { }, which is the placeholder
the variable name or a constant

Scalar Types

a scalar type represents a single value

Integer
Floating-point
Boolean
Character

Integer

Integer Range
Integer Overflow

an integer is a number without a fractional component
represents whole numbers

integers can be further classified as Signed and Unsigned
Signed integers can store both negative and positive values
Unsigned integers can only store positive values

Size	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

Integer Range

each signed variant can store numbers from -(2^(n-1) to 2^(n-1) -1
n is the number of bits that variant uses
example - i8 can store numbers from -(2^7) to 2^7 -1 (replaced n with 8)

each unsigned variant can store numbers from 0 to (2^n)-1
example - u8 can store numbers from 0 to (2^8)-1 (equal to 0 to 255)

Integer Overflow

integer overflow occurs when the value assigned to an integer variable exceeds the Rust defined range for the data type
example

fn main() {
   let age:u8 = 255;

   // 0 to 255 only allowed for u8
   let weight:u8 = 256;   //overflow value is 0
   let height:u8 = 257;   //overflow value is 1
   let score:u8 = 258;    //overflow value is 2

   println!("age is {} ",age);
   println!("weight is {}",weight);
   println!("height is {}",height);
   println!("score is {}",score);
}

the valid range of unsigned u8 variable is 0 to 255
above the variables are assigned values greater than 255 (upper limit for an integer variable in Rust)
the file won't compile because the compiler throws out-of-range errors
warnings and error messages provide significant details

Float

Automatic Type Casting
Number Separator

Float data type in Rust can be classified as f32 and f64
f32 type is a single-precision float
f64 is double precision
default type is f64

fn main() {
   let result = 10.00;        //f64 by default
   let interest:f32 = 8.35;
   let cost:f64 = 15000.600;  //double precision
   
   println!("result value is {}",result);
   println!("interest is {}",interest);
   println!("cost is {}",cost);
}

output

interest is 8.35
cost is 15000.6

Automatic Type Casting

Rust does not perform automatic type casting
compiler throws a mismatched types error

fn main() {
   let interest:f32 = 8;   // integer assigned to float variable
   println!("interest is {}",interest);
}

Number Separator

or easy readability of large numbers,can use a visual separator _ underscore to separate digits

fn main() {
   let float_with_separator = 11_000.555_001;
   println!("float value {}",float_with_separator);
   
   let int_with_separator = 50_000;
   println!("int value {}",int_with_separator);
}

output

float value 11_000.555_001
int value 5_0000

Boolean

use the bool keyword to declare a boolean variable

fn main() {
   let isfun:bool = true;
   println!("Is Rust Programming Fun ? {}",isfun);}

Character

the character data type in Rust supports numbers, alphabets, Unicode and special characters
use the char keyword to declare a variable of character data type
char type represents a Unicode Scalar Value
can represent a lot more than just ASCII. Unicode Scalar Values range from U+0000 to U+D7FF and U+E000 to U+10FFFF inclusive

fn main() {
   let special_character = '@'; //default
   let alphabet:char = 'A';
   let emoji:char = "\u{2665}";
   
   println!("special character is {}",special_character);
   println!("alphabet is {}",alphabet);
   println!("emoji is {}",emoji);
}