- Rust is a systems programming language designed for performance and safety.
- It offers features that make it particularly well-suited for applications requiring concurrency, low-level control, and memory safety.
- Speed and Efficiency: Rust provides a fast and memory-efficient language with zero-cost abstractions.
- Ownership Model: Rust's ownership model ensures memory safety and prevents data races.
- Reliability: Compile-time checks catch bugs early, resulting in highly reliable software.
- Concurrency: Built-in support for concurrent programming.
- Parallel Programming: Simplifies building parallel applications.
- Ease of Deployment: Produces executables with minimal runtime dependencies.
- Real-Time Systems: Ideal for real-time and embedded systems due to its performance.
# To check the version.
rustc --version
# To create a new project.
cargo new rust_first
# To compile the project.
cargo build
# To run the project. (Single Step)
cargo run
# To create library crate.
cargo new name --lib
# Run all tests
cargo test
# Run specific test file
cargo test --test integration_test
# Run tests with output
cargo test -- --nocapture
# Run ignored tests
cargo test -- --ignored
# Run with release profile.
cargo build --release- Rust emphasizes
immutabilityby default, ensuring datasafetyandpredictability. - However, variables can be made
mutablefor cases requiring value reassignment. - The
letkeyword is used to declare variables, while additional keywords likemutmodify their behavior. - We can declare a variable to
changeit's data-type or value, calledshadowing.
- Immutable by Default: Encourages functional programming principles.
- Explicit Mutability: Requires deliberate use of
mutfor mutable variables. - Static Typing: Rust ensures type safety at compile time, minimizing runtime errors.
- Rust provides a robust type system to ensure safety and performance.
- Data types in Rust can be categorized as scalar or compound.
- Integer: Represents whole numbers with varying sizes and signs (e.g., signed and unsigned).
- Floating-Point: Represents numbers with fractional parts and adheres to IEEE-754 standards.
- Boolean: Denotes logical values,
trueorfalse. - Character: Represents Unicode scalar values, supporting a wide range of symbols and characters.
- Arrays: Fixed-size collections of elements of the same type, providing
contiguousmemory storage. - Tuples: Fixed-size
orderedcollections that can containmultipledata types, ideal for grouping related values.
- Slices allow efficient
referencingof subsets of data within collections. - They are particularly useful for working with arrays without
copyingdata, promoting memoryefficiency.
Rust offers two primary string types:
- String: An owned,
growablestring stored on the heap, allowingdynamicmodification. - &str: A borrowed,
immutablestring slice, typically used for efficient,read-onlyoperations.
Functions
< 778E a id="user-content-functions" class="anchor" aria-label="Permalink: Functions" href="#functions">- Functions in Rust are the building blocks of code, enabling modular and reusable design.
- Defined using the
fnkeyword, functions enforce strict type annotations for parameters and return values, ensuring clarity and correctness.
- Type Safety: Every parameter and return value must have an explicitly defined type.
- Reusable Logic: Functions promote modular design and reduce code duplication.
- Pure Functions: Rust encourages writing functions without side effects, enhancing predictability.
Rust provides robust mechanisms for error handling, avoiding traditional exceptions in favor of explicit types like `Result` and `Option`.
These are errors that can be addressed by the program, allowing it to continue execution. Rust uses the `Result` type to encapsulate outcomes that can either succeed or fail.
These errors signify critical issues that prevent the program from continuing. Rust handles such scenarios using the panic! macro, which immediately terminates the program.
Error propagation allows errors to be passed up the call stack to be handled at higher levels. Techniques include:
- The
?Operator: Simplifies propagating errors in functions. - Custom Error Types: Enables detailed and domain-specific error reporting.
The `Option` type is used to represent optional values. It explicitly handles cases where data may be absent, ensuring safe and predictable behavior.
- Explicit Null Safety: Eliminates the risk of null pointer exceptions.
- Variants: Represents values as either
Some(value)orNone. - Seamless Integration: Works with other Rust features like pattern matching for elegant handling of optional data.
- Perf: Generate flamegraphs to collect and analyze performance.
perf record -g ./name
perf script | ./flamegraph.p1 > flamegraph.svg- cargo-profiler: Simplifies by automating the setup and execution of performance tests.