Blogging Community Data types in Rust - Technologies In Industry 4.0

Data types in Rust


  • Every value in Rust has a unique data type.
  • Rust automatically define primitive data type without explaining it explicitly.
  • Rust is surely a statically typed language, which describes that it must know the kinds of all variables at compile time.

Data types in RUST:

Scalar type

A scalar type represents one value. Rust has four primary scalar types.

○ Integer.

○ Floating-point.

○ Boolean.

○ Character

Compound type

The Compound type can group multiple values into one type. Rust has two primitive compound types.

○ Tuples

○ Arrays

Scalar type

Integer type

Length                                     Signed                                     Unsigned

8-bit                                             i8                                               u8

16-bit                                           i16                                             u16

32-bit                                           i32                                             u32

64-bit                                           i64                                             u64

Arch                                             isize                                          usize

  • Each integer in Rust is often either signed or unsigned and has a particular size.
  • The isize and usize types depend on the type of computer our program is running on 64 bits if we’re on a 64-bit architecture and 32 bits if you’re on 32-bit architecture.
  • Once we do not declare the type of an integer then Rust will by default take i32 for an integer.
  • Each signed variant may store numbers from -(2n – 1) to 2n – 1 – 1 inclusive.
  • The unsigned variants may store numbers from 0 to 2n – 1. let variable: u32 = 100; we will write integer literals in any of the forms given below

Number literals Example

  • Decimal                                      98_222
  • Hex                                             0xff
  • Octal                                           0o77
  • Binary                                         0b1111_0000
  • Byte                                            (u8 only) b’A’

Floating-Point Types:

  • The Rust has also two primitive types for floating-point numbers, these are numbers having decimal points.
  • The Rust’s floating-point types are included f32 and f64, these are 32 bits and 64 bits in size, respectively.
  • If we don’t declare the type of floating-point then Rust will by default take f64 for that floating-point type.
  • The f32 type has a single-precision float, and f64 has double precision.
  • let variable: f32 = 1.23;

Boolean Type:

  • In Rust, a Boolean type has two possible values: true and false.
  • Booleans are one byte in size.
  • In Rust, the Boolean type is specified using bool.
  • let variable: bool = true;

Character Type:

  • Rust supports letters too.
  • Char type in Rust is that the language’s most primitive alphabetic type.
  • The characters are specified with single quotes, as against string literals, which use quotation marks.
  • Char type of Rust is four bytes in size and represents a Unicode Scalar Value.
  • let c = ‘z’;

Compound Type

Tuple Type:

  •  The tuple may be a general way of grouping together some number of other values with a spread of types.
  • The Tuples have a hard and fast length, once declared; they can’t grow or shrink in size. Contain heterogeneous data.
  • We generate a tuple by writing a comma-separated list of values inside parentheses. We will access a tuple element directly by employing a period (.) followed by the index of the worth we would like to access.

Array Type:

  • To possess differently a set of multiple values is with an array containing homogeneous data.
  • Each and every element of an array must have an equivalent type not the type of a Tuple.
  • With square brackets writing an array’s type is completed containing the sort of every element within the array followed by a semicolon and therefore the number of elements within that array. We would access elements of an array using indexing in brackets.
  • The array isn’t flexible and is not allowed to grow or shrink in size.
  • The Declaration: let array = [1, 2, 3, 4, 5];
  • Accessing an array element: let value1 = array[0];
  • Example let a = [1, 2, 3, 4, 5];println!(“The value of}
  • Result: the worth of element is: 4
  • element is: {}”, a[element]);
  • let element = 3;
  • fn main() {