Rust Operators Explained: Math, Bitwise, and Boolean Operations

Rust scalar (primitive) types include: integers (i8, i16, i32, i64, i128, u8, u16, u32, u64, u128), floating point numbers (f32, f64), booleans (bool), and characters (char). Rust supports multiple integer literal formats (decimal, binary, octal, hexadecimal) and can automatically infer types. The compiler requires explicit type declaration when variables are declared without initial values.

Scalar data types represent single values and include integers, floating-point numbers, booleans, and characters. Integers are numbers without fractional components and come in signed (positive/negative) and unsigned (only positive) varieties with sizes of 8, 16, 32, 64, 128 bits, or architecture-dependent (usually 32 or 64-bit). Rust defaults to 32-bit integers. Floating-point numbers have decimal points and default to 64-bit double precision. Booleans represent true/false values, and characters represent Unicode values written with single quotes.

Rust provides multiple integer types: i8, i16, i32, i64, and i128 for signed integers, and u8, u16, u32, u64, and u128 for unsigned integers. The default integer type is i32 (32-bit signed integer). Floating point types include f32 (32-bit) and f64 (64-bit), with f64 as the default. Boolean values are represented by the bool type with true and false values. Rust infers types based on literal values, with small integers defaulting to i32 and floating point literals defaulting to f64. This inference system reduces boilerplate while ensuring type safety.

Rust has four primary scalar types: integers, floating-point numbers, booleans, and characters. Integers use 'i' for signed (negative values) and 'u' for unsigned (non-negative). Sizes range from i8 to isize, with isize depending on architecture. Literals support decimal, hex, and octal formats with type suffixes. Floats use f32 and f64 (default). Booleans are true/false. Characters use single quotes and represent Unicode scalar values.

Rust's primitive types are divided into scalar types (integers, floats, booleans, and characters) and compound types (tuples and arrays). Scalar types store single values: integers (i8, i16, i32, i64 for signed; u8, u16, u32, u64 for unsigned) with ranges determined by bit size, floats (f32, f64) for decimal numbers, booleans (true/false) for conditions, and characters (char) for single Unicode symbols. Compound types aggregate multiple values: tuples (fixed-size, heterogeneous collections using parentheses) and arrays (fixed-size, homogeneous collections using square brackets). Rust provides compile-time overflow protection for integers and bounds checking for arrays, ensuring type safety and memory safety.

The 'let' keyword is used to declare variables that can be reassigned with new values. Variables declared with 'let' are mutable, meaning their values can change after initial assignment. This is useful when values need to be updated during program execution.

Rust variables are immutable by default, meaning their values cannot be changed after initial assignment. To make a variable mutable, add the 'mut' keyword after 'let'. Once mutable, you can assign new values multiple times. You can update a variable's value by assigning a new value directly (age = 21) or by using expressions (age = age + 1). The compiler evaluates the expression first, then assigns the result to the variable. This immutability is a key safety feature that prevents accidental modification of data.

Rust variables are declared using 'let' followed by the variable name and value. Unlike Python, Rust requires explicit type annotation (e.g., 'let x: i32 = 5'). Rust has type inference, automatically determining variable types from assigned values. By default, all variables are immutable (constant). To make a variable mutable, use the 'mut' keyword (e.g., 'let mut x = 3'). The compiler warns when variables are declared but never used, helping identify potential bugs.

const and let are keywords used to declare variables, not the variables themselves. The name after the keyword is the variable name, and the equals sign is the assignment operator. const creates immutable variables that cannot be changed after assignment, while let creates mutable variables that can be changed. For arrays and objects, const freezes the variable preventing additions or edits, while let allows modification. VAR was the only way to declare variables for the first 20+ years of JavaScript but is no longer preferred. Modern browsers support mixing VAR with let/const without issues.

In Rust, variables are declared using the 'let' keyword and are immutable by default, meaning their values cannot be changed after assignment; to create mutable variables, use 'let mut', and constants are declared with 'const' and are always immutable with uppercase names; Rust also supports variable shadowing, which allows redeclaring variables with the same name in nested scopes, enabling type changes while the original variable remains unchanged.

A bit (binary digit) is the smallest unit of information a computer can process, representing either 0 or 1. Each bit occupies one unit of memory in the computer. A byte is a group of 8 bits that together form a single unit of digital information. For example, the decimal number 132 converts to binary as 10000100, which consists of 8 bits and therefore equals 1 byte. This relationship between bits and bytes is fundamental to understanding computer memory, data storage, and information processing. The binary number 1100001 consists of 7 bits, occupying 7 bits of storage space.

A byte (B maiúsculo) consists of 8 bits grouped together, while a bit (B minúsculo) is a binary digit that can be 0 or 1. The relationship is: 1 byte = 8 bits, 2 bytes = 16 bits. Computers process data by counting bits in sequence and grouping them into bytes. The notation convention uses uppercase B for bytes and lowercase b for bits. This distinction is crucial for correctly interpreting technical specifications like storage devices (16 GB means 16 gigabytes) and network speeds (10 Mbps means 10 megabits per second).

Binary language is the fundamental system computers use to store and process data, where information can only assume two states: 0 or 1. A 'bit' (dígito binário) is the smallest unit of information, representing either 0 or 1. The number of possible information combinations with n bits follows the formula 2^n: 1 bit = 2 possibilities, 2 bits = 4 possibilities, 3 bits = 8 possibilities, and 8 bits = 256 possibilities. A byte is defined as 8 bits grouped together, with 1 byte = 8 bits. The distinction between lowercase 'b' (bit) and uppercase 'B' (byte) is critical: '16 GB' means gigabytes, while '10 Mbps' means megabits per second. To convert bits to bytes, divide by 8; to convert bytes to bits, multiply by 8. Each character typed on a keyboard is converted into 8 bits (1 byte) using encoding standards like ASCII.

A bit is the fundamental unit of information representing one of two states (0 or 1). A byte consists of eight consecutive bits. Multiple bits combine to represent larger numbers through positional weighting: 1 bit = 2 values, 2 bits = 4 values, 3 bits = 8 values, 4 bits = 16 values. This exponential growth follows 2^n where n is the number of bits. Four bits can represent all decimal digits (0-9) with extra capacity. One byte (8 bits) can represent 256 different values (0-255).

A bit is the smallest unit of data in computing, represented by either 0 or 1. Eight bits together form one byte. Two bits are called a nibble (or sometimes called a nibble). Four bits constitute one nibble. Therefore, one byte equals two nibbles. This fundamental relationship between bits, nibbles, and bytes is essential for understanding computer data storage and processing.