Summary of Data Types in Rust

Introduction

In Rust, data types are fundamental as they define the kind of data a variable can hold. Understanding these types is key to writing safe and efficient code.

Key Concepts

1. Scalar Types

• Scalar types represent a single value.
• There are four primary scalar types in Rust:
  • Integers: Whole numbers (e.g., i32, u32, etc.)
    Example: let x: i32 = 10;
  • Floating-point Numbers: Numbers that can have a fractional part (e.g., f32, f64).
    Example: let y: f64 = 3.14;
  • Booleans: Represents a value that can be either true or false.
    Example: let is_rust_fun: bool = true;
  • Characters: Represents a single Unicode character.
    Example: let letter: char = 'A';

2. Compound Types

• Compound types can group multiple values into one type.
• Two main compound types in Rust:
  • Tuples: A fixed-size collection of values of different types.
    Example: let tup: (i32, f64, char) = (500, 6.4, 'z');
  • Arrays: A fixed-size collection of values of the same type.
    Example: let arr: [i32; 3] = [1, 2, 3];

Type Inference

Rust can often infer types based on the context, reducing the need to specify types explicitly.
Example: let x = 5; (Rust infers x as i32)

Conclusion

Understanding data types is crucial for effective Rust programming. Knowing when to use scalar versus compound types allows developers to structure their data efficiently and safely. By grasping these basic concepts, beginners can start building their Rust applications with confidence.