DEV Community: Sureni Dhanasekara

Advance Types In Rust

Sureni Dhanasekara — Fri, 13 Jun 2025 14:51:22 +0000

Rust is known for its powerful type system, which enables memory safety, concurrency, and zero-cost abstractions. Rust basic types like integers, boolean, and strings are straightforward, advanced types provide the foundation for writing expressive and safe code in complex systems.

Most important advanced types in Rust:

Algebraic Data Types (Enums & Structs)
Type Aliases
Newtypes
PhantomData
Dynamically Sized Types (DSTs)
Trait Objects
Function Pointers
Never Type (!)
Inferred and Generic Types

Algebraic Data Types (ADTs)

Algebraic data types is a way to define complex data by combining simpler types.

There are two main kinds of ADTs:

Struct : combine multiple fields together

    struct Person {
      name: String,
      age: u8,
    }

Enum : define one of many possibilities

    enum Shape {
      Circle(f64),
      Rectangle(f64, f64),
   }

Newtypes

A newtype is just a tuple struct with one field which is used to create a new, distinct type from an existing type.

struct MyType(i32);

Why Use Newtypes:

Type safety :two types with the same inner value not interchangeable, so you can’t accidentally pass Meters when Millimeters is expected.

struct Millimeters(u32);
struct Meters(u32);

Example without newtype:

fn print_length(length_mm: u32) {
    println!("Length is {} millimeters", length_mm);
}

let meters = 5; 
print_length(meters);

If we passed 5 meters where the function expected millimeters. But Rust doesn’t catch this, because they’re both just u32.

Example with newtype:

struct Millimeters(u32);
struct Meters(u32);

fn print_length(length_mm: Millimeters) {
       println!("Length is {} millimeters", length_mm.0);
}

let meters = Meters(5);
print_length(meters); // ❌ ERROR!

If we run this then you will get a compile-time error:

expected struct `Millimeters`, found struct `Meters`

Custom Trait Implementations: Rust doesn't let you implement foreign traits for foreign types that means you can't implement a trait like Display for a built-in type like Vec unless you own either the trait or the type. We can solve this issue with newtype.

use std::fmt;

struct CommaSeparated(Vec<String>);

impl fmt::Display for CommaSeparated {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.0.join(", "))
    }
}

fn main() {
    let names = CommaSeparated(vec!["Alice".into(), "Bob".into(), "Carol".into()]);
    println!("{}", names); // prints: Alice, Bob, Carol
}

Encapsulation: Encapsulation means hiding internal details of a type and exposing only what’s necessary.

It’s a core idea in programming that helps:

Prevent misuse
Keep your codebase clean
Make changes without breaking other code

In Rust, this is done using:

Private fields
Public methods (getters/setters or controlled logic)

pub struct Password(String); // type is public, field is private

impl Password {
    pub fn new(s: &str) -> Self {
        Password(s.to_string())
    }

    pub fn value(&self) -> &str {
        &self.0
    }
}

Type Aliases

A type alias in Rust lets you create a new name for an existing type - but it doesn't create a new, distinct type.

type Kilometers = i32;

fn main() {
    let distance: Kilometers = 5;
    let total: i32 = distance + 10; // Works — because Kilometers is just an alias for i32
}

PhantomData

PhantomData is a zero-sized marker type in Rust that's used to indicate that a type or lifetime parameter is logically "used" by your type, even though it doesn't actually contain any data of that type.

Key Properties:

Zero-sized (no runtime overhead)
Only used at compile time for type system purposes
Doesn't affect runtime behavior
Can be used with any combination of type and lifetime parameters

Dynamically Sized Types (DSTs)

In Rust, most types must have a known size at compile time. But DSTs are types whose size is only known at runtime.

Key Characteristics of DSTs :
- Size unknown at compile time
- Must always be used behind a pointer (&, Box, Rc, etc.)

- Don't implement the Sized trait

Common DSTs in Rust:

Slices ([T])

let slice: &[i32] = &[1, 2, 3];  // DST - size depends on runtime length

Trait Objects (dyn Trait)

let trait_obj: &dyn Display = &42;  // DST - size depends on concrete type

Structs with DST as last field

struct MyString {
    len: usize,
    data: [u8],  // DST as last field
}

Never Type (!)

The ! type in Rust means "this function never returns".

Key Characteristics:

Diverging functions: Functions that never return have return type !
Zero variants: The ! type has no possible values
Subtype of all types: Can be coerced into any other type
No runtime representation: Doesn't exist at runtime.

Examples:

A Function That Panics - The return type is ! because this function never returns normally it always panics.

fn crash() -> ! {
    panic!("Something went terribly wrong");
}

An Infinite Loop

fn loop_forever() -> ! {
    loop {
        // runs forever
    }
}

Function Pointers

Function pointers in Rust allow you to store references to functions and pass them around like regular values. They're a fundamental building block for many advanced patterns like callbacks, plugins, and strategy patterns.

Basic Function Pointer Syntax:

fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn main() {
    // Create a function pointer
    let operation: fn(i32, i32) -> i32 = add;

    // Use the function pointer
    let result = operation(2, 3);
    println!("Result: {}", result); // Prints "5"
}

Key Characteristics:

Type Signature: Function pointers have the type fn(T1, T2, ...) -> R where Tn are argument types and R is the return type
Zero-Sized: They don't store any data, just point to code
Safe: Unlike raw pointers, function pointers are guaranteed to point to valid functions
No Capture: They can only point to functions, not closures that capture environment

Rust Error Handling

Sureni Dhanasekara — Wed, 30 Apr 2025 04:52:52 +0000

Rust groups errors into two major categories:

recoverable errors
unrecoverable error

Recoverable Errors

When it is recoverable error then problem will report to the user and and retry the operation. This errors handle with the type Result since exception is not available in rust.

Ex: File not found error

Unrecoverable Errors

Unrecoverable errors are always symptoms of bugs. This errors handle with the panic! macro and it will stop execution.

Ex: trying to access a location beyond the end of an array.

Recoverable Errors with Result

Result enum is defined as having two variants, Ok and Err, as follows:

 enum Result<T, E> {
    Ok(T),
    Err(E),
 }

This T and E mention in here Result<T, E> are generic type parameters.
T represent the type of value that will be return in success case and E represent the type of value that will be return in error/failure case.

use std::fs::File; 
fn main() { 
    let f:u32 = File::open("program.txt"); 
}

 error[E0308]: mismatched types
 --> src/main.rs:4:18
  |
 4 |     let f: u32 = File::open("hello.txt");
  |                  ^^^^^^^^^^^^^^^^^^^^^^^ expected u32, found enum 
`std::result::Result`
  |
  = note: expected type `u32`
             found type `std::result::Result<std::fs::File, std::io::Error>`

We can modify code as follows to handle error:

use std::fs::File;
use std::io::Error;

fn main() {
    let f = File::open("program.txt");
    match f {
        Ok(_file) => println!("File opened successfully"),
        Err(e) => println!("Error opening file: {}", e),
    }
}

Unrecoverable Errors with panic!

When the panic! macro executes, your program will print a failure message, unwind and clean up the stack, and then quit.

unwind - Rust walks back up the stack and cleans up the data from each function it encounters.
abort - Ends the program without cleaning up. Memory that the program was using will then need to be cleaned up by the operating system.

if you are using abort then need to do modification in Cargo.toml as follows:
panic = 'abort'

fn main() {
    panic!("This is an unrecoverable error!");
}

Output:

Compiling testing v0.1.0 (C:\Users\Sanija Methsen\Desktop\Rust\my-projects\testing)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.93s
     Running `target\debug\testing.exe`

thread 'main' panicked at src\main.rs:2:5:
This is an unrecoverable error!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: process didn't exit successfully: `target\debug\testing.exe` (exit code: 101)
PS C:\Users\Sanija Methsen\Desktop\Rust\my-projects\testing>

Using a panic! Backtrace
A backtrace is a detailed report showing the sequence of function calls that occurred before the panic, which is extremely helpful for debugging.

Enable full backtraces:

For Linux/Mac (Bash/Zsh):
RUST_BACKTRACE=1 cargo run

For Windows Command Prompt (CMD):
set RUST_BACKTRACE=1
cargo run

Output

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.04s
Running `target\debug\testing.exe`

thread 'main' panicked at src\main.rs:2:5:
This is an unrecoverable error!
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: process didn't exit successfully: `target\debug\testing.exe` (exit code: 101)

Enable full backtraces with more details:

For Linux/Mac (Bash/Zsh):
RUST_BACKTRACE=full cargo run

For Windows Command Prompt (CMD):
set RUST_BACKTRACE=full
cargo run

Output

Compiling testing v0.1.0 (C:\Users\Sanija Methsen\Desktop\Rust\my-projects\testing)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.10s
     Running `target\debug\testing.exe`

thread 'main' panicked at src\main.rs:2:5:
This is an unrecoverable error!
stack backtrace:
   0:     0x7ff767896511 - std::backtrace_rs::backtrace::win64::trace
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\..\..\backtrace\src\backtrace\win64.rs:85
   1:     0x7ff767896511 - std::backtrace_rs::backtrace::trace_unsynchronized
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\..\..\backtrace\src\backtrace\mod.rs:66
   2:     0x7ff767896511 - std::sys::backtrace::_print_fmt
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\sys\backtrace.rs:66
   3:     0x7ff767896511 - std::sys::backtrace::impl$0::print::impl$0::fmt
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\sys\backtrace.rs:39
   4:     0x7ff7678a299a - core::fmt::rt::Argument::fmt
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\core\src\fmt\rt.rs:177
   5:     0x7ff7678a299a - core::fmt::write
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\core\src\fmt\mod.rs:1449
   6:     0x7ff7678948e7 - std::io::Write::write_fmt<std::sys::pal::windows::stdio::Stderr>
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\io\mod.rs:1890
   7:     0x7ff767896355 - std::sys::backtrace::BacktraceLock::print
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\sys\backtrace.rs:42
   8:     0x7ff767897892 - std::panicking::default_hook::closure$0
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:298
   9:     0x7ff767897683 - std::panicking::default_hook
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:325
  10:     0x7ff76789837f - std::panicking::rust_panic_with_hook
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:831
  11:     0x7ff7678981d2 - std::panicking::begin_panic_handler::closure$0
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:697
  12:     0x7ff767896c4f - std::sys::backtrace::__rust_end_short_backtrace<std::panicking::begin_panic_handler::closure_env$0,never$>
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\sys\backtrace.rs:168
  13:     0x7ff767897e0e - std::panicking::begin_panic_handler
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:695
  14:     0x7ff7678a7551 - core::panicking::panic_fmt
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\core\src\panicking.rs:75
  15:     0x7ff76789118b - testing::main
                               at C:\Users\Sanija Methsen\Desktop\Rust\my-projects\testing\src\main.rs:2
  16:     0x7ff76789106b - core::ops::function::FnOnce::call_once<void (*)(),tuple$<> >
                               at C:\Users\Sanija Methsen\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\ops\function.rs:250
  17:     0x7ff76789113e - core::hint::black_box
                               at C:\Users\Sanija Methsen\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\hint.rs:477   
  18:     0x7ff76789113e - std::sys::backtrace::__rust_begin_short_backtrace<void (*)(),tuple$<> >
                               at C:\Users\Sanija Methsen\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\std\src\sys\backtrace.rs:152
  19:     0x7ff767891121 - std::rt::lang_start::closure$0<tuple$<> >
                               at C:\Users\Sanija Methsen\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\std\src\rt.rs:199      
  20:     0x7ff767892d5c - std::rt::lang_start_internal::closure$0
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\rt.rs:168
  21:     0x7ff767892d5c - std::panicking::try::do_call
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:587
  22:     0x7ff767892d5c - std::panicking::try
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panicking.rs:550
  23:     0x7ff767892d5c - std::panic::catch_unwind
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\panic.rs:358
  24:     0x7ff767892d5c - std::rt::lang_start_internal
                               at /rustc/05f9846f893b09a1be1fc8560e33fc3c815cfecb/library\std\src\rt.rs:164
  25:     0x7ff76789110a - std::rt::lang_start<tuple$<> >
                               at C:\Users\Sanija Methsen\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\std\src\rt.rs:198      
  26:     0x7ff7678911a9 - main
  27:     0x7ff7678a5ec0 - invoke_main
                               at D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:78
  28:     0x7ff7678a5ec0 - __scrt_common_main_seh
                               at D:\a\_work\1\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288
  29:     0x7ffe69e0259d - BaseThreadInitThunk
  30:     0x7ffe6b14af38 - RtlUserThreadStart
error: process didn't exit successfully: `target\debug\testing.exe` (exit code: 101)

Disable backtraces:

For Linux/Mac (Bash/Zsh):
RUST_BACKTRACE=0 cargo run

For Windows Command Prompt (CMD):
set RUST_BACKTRACE=0
cargo run

Output

thread 'main' panicked at 'Test panic', src\main.rs:2:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Unwrap and expect
unwrap will return the value inside the Ok. If the Result is the Err variant, unwrap will call the panic! macro for us.

let num = "42".parse::<i32>().unwrap(); // Panics on Err

Using expect instead of unwrap and providing good error messages can convey your intent and make tracking down the source of a panic easier.

let num = "42".parse::<i32>().expect("Parsing failed"); // Panics with custom message

Propagating Errors
Error propagation is a fundamental concept in Rust that allows errors to be passed up the call stack to be handled by calling functions. The ? operator is Rust's primary mechanism for error propagation:

use std::fs;
use std::io;

fn read_config() -> Result<String, io::Error> {
    let content = fs::read_to_string("config.toml")?;
    Ok(content)
}

fn main() -> Result<(), io::Error> {
    let config = read_config()?;
    println!("Config: {}", config);
    Ok(())
}

Helpful Crates
thiserror: For defining library error types
anyhow: For application error handling
snafu: Alternative error handling with backtraces
miette: Fancy diagnostic error reporting

Testing Rust

Sureni Dhanasekara — Tue, 29 Apr 2025 11:41:26 +0000

The two pillars of rust are

speed
safety

Rust built in safety features

Borrow checker
Type system
Pattern matching

Borrow checker
The borrow checker is an useful feature of the Rust language. It helps to manage ownership.

fn main() {
    let s1:String = String::from("Hello Rust");
    let s2: String = s1;

    println!("string is : {}", s1);
}

If we run this main then it will provide error like follows:

error[E0382]: borrow of moved value: `s1`
 --> src\main.rs:5:32
  |
2 |     let s1:String = String::from("Hello Rust");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 |     let s2: String = s1;
  |                      -- value moved here
4 |
5 |     println!("string is : {}", s1);
  |                                ^^ value borrowed here after move
  |

Type system
Rust type system is designed to guarantee safety and performance in your programs.

Rust's type system is one of its most powerful features, providing safety, expressiveness, and performance in your programs. Core characteristics of rust are:
- Statically typed: All types are known at compile time.
- Strongly typed: No implicit type conversions.
- Type inference: Compiler can often deduce types.
- Zero-cost abstractions: High-level constructs compile to
efficient low-level code.

Basic types of rust are:

Scalar Types
1. Integers: i8, i16, i32, i64, i128, isize (signed); u8, u16, u32, u64, u128, usize (unsigned)
2. Floats: f32, f64
3. Boolean: bool (true/false)
4. Character: char
Compound Types
1. Tuples: Fixed-size, heterogeneous collections
2. Arrays: Fixed-size, homogeneous collections
Custom Types
1. Structs
2. Enums

Pattern matching
Pattern matching enables you to match and destructure data according to its type, structure, or other attributes. It offers a clear and expressive approach to handling various situations and reaching conclusions in light of them. Because of Rust's thorough pattern matching, you must take into consideration every potential pattern to guarantee that your code is comprehensive and error-free.

Rust's Standard Library gives us three assertion macros that helps us build our testing scenarios.

assert! - evaluates a specific condition, which passes the test if that condition is true, and triggers a failure with a panic if that condition is false.
assert_eq! - compares two values for equality, passing the test if they're equal and detailing the discrepancy if they're not.
assert_ne! - checks for inequality between two values, passing the test if they are unequal and detailing if they are equal.

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

we can run test by cargo test. The it will give output as follows:

   Compiling rust_testing v0.1.0 (C:\Users\Sanija Methsen\Desktop\Rust\my-projects\rust_testing)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 3.32s
     Running unittests src\lib.rs (target\debug\deps\rust_testing-7cd7699070227f78.exe)

running 1 test
test tests::it_works ... ok

successes:

successes:
    tests::it_works

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

if the answer is not correct then it'll display failed message in terminal

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(10, 2);
        assert_eq!(result, 4);
    }
}

---- tests::it_works stdout ----

thread 'tests::it_works' panicked at src\lib.rs:12:9:
assertion `left == right` failed
  left: 12
 right: 4
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::it_works

test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib

Rust have the option to tag along a custom message with the failure alert whenever you use the assert!, the assert_eq!, or the assert_ne! macros.

pub fn sum(left: u64, right: u64) -> u64 {
    left + right
}

pub fn subtract(left: u64, right: u64) -> u64 {
    left - right
}

pub fn is_even(num:i32) -> bool {
    num % 2 == 0
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_sum() {
        assert_eq!(4, sum(2, 2), "calculating sum failed");
    }

    #[test]
    fn test_subtract() {
        assert_eq!(4, subtract(6, 2), "calculating subtraction failed");
    }

    #[test]
    fn test_is_even() {
        assert!(is_even(3), "number is not even");
    }
}

output:

PS C:\Users\Sanija Methsen\Desktop\Rust\my-projects\rust_testing> cargo test
   Compiling rust_testing v0.1.0 (C:\Users\Sanija Methsen\Desktop\Rust\my-projects\rust_testing)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 1.64s
     Running unittests src\lib.rs (target\debug\deps\rust_testing-7cd7699070227f78.exe)

running 3 tests
test tests::test_is_even ... FAILED
test tests::test_subtract ... FAILED
test tests::test_sum ... FAILED

failures:

---- tests::test_is_even stdout ----

thread 'tests::test_is_even' panicked at src\lib.rs:30:9:
number is not even
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

---- tests::test_subtract stdout ----

thread 'tests::test_subtract' panicked at src\lib.rs:25:9:
assertion `left == right` failed: calculating subtraction failed
  left: 4
 right: 3

---- tests::test_sum stdout ----

thread 'tests::test_sum' panicked at src\lib.rs:20:9:
assertion `left == right` failed: calculating sum failed
  left: 4
 right: 5


failures:
    tests::test_is_even
    tests::test_subtract
    tests::test_sum

test result: FAILED. 0 passed; 3 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s

There is a anothor marco for testing. That is panic!. This verifies that function panics as expected during testing, and checks that the panic message matches specific text.

pub fn divide(num1:i32, num2:i32) -> i32 {
    if num2 == 0 {
        panic!("divide by zero not allowed");
    }
    num1 / num2
}

#[test]
#[should_panic(expected="Divide by zero not allowed")]
fn test_check_divide() {
   divide(10, 0);
}

running 1 test
test tests::test_check_divide - should panic ... ok

if #[should_panic(expected="Divide by zero not allowed")] not included to test function then it will throw an error. If we use

 #[test]
    #[should_panic(expected="Divide by zero not allowed")]
    fn test_check_divide() {
        divide(10, 2);
    }

then test will be fail.

running 1 test
test tests::test_check_divide - should panic ... FAILED

Result type
Using result type in testing is one clever way to handle success and failure events in tests.

pub fn is_even(num:i32) -> bool {
    num % 2 == 0
}

#[test]
fn test_even_number() -> Result<(), String> {
    if is_even(4) {
        Ok(())
    } else {
        Err(String::from("Expected 4 to be even"))
    }
}

output:

running 1 test
test tests::test_even_number ... ok

successes:

successes:
    tests::test_even_number

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Test Attributes
#[test] - Indicates a function is a test to be run. This function takes no arguments.
#[bench] - Indicates a function is a benchmark to be run. This function takes one argument (test::Bencher).
#[should_panic] - This function (also labeled with #[test]) will only pass if the code causes a panic (an assertion failure or panic!) A message may be provided, which the failure string must contain:
#[should_panic(expected = "foo")].
#[ignore]- When applied to a function which is already attributed as a test, then the test runner will ignore these tests during normal test runs. Running with --ignored or --include-ignored will run these tests.

Unit tests

Unit tests are essential elements of Rust's testing framework. They are the primary lines of defense against bugs. They're quick to write, quick to run, and they zero in on the smallest part of our system, our functions and our methods. So their speed and precision make them ideal for very quick iterations, allowing us to confirm that each piece of our code operates exactly as intended. Unit tests are just as important in binary applications as they are in libraries.The standard practice is that you put these test functions in a test module inside each file and you annotate the module with cfg test. cfg test attribute is Rust's way of optimizing the testing process. So when we append this attribute to a module, we're telling Rust to compile and execute the code exclusively when we run cargo test not when you run cargo build.

 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }
 }

Running single test
We can pass the name of any test function to cargo test to run only that test:

 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn add_two_and_two() {
        assert_eq!(4, add_two(2));
    }
    #[test]
    fn add_three_and_two() {
        assert_eq!(5, add_two(3));
    }
    #[test]
    fn one_hundred() {
        assert_eq!(102, add_two(100));
    }
 }

Run the test:

$ cargo test one_hundred

Filtering to Run Multiple Tests
We can specify part of a test name, and any test whose name matches that value will be run.

 $ cargo test add
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running target/debug/deps/adder-06a75b4a1f2515e9
 running 2 tests
 test tests::add_two_and_two ... ok
 test tests::add_three_and_two ... ok
 test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out

Integration tests

Integration tests are conducted outside of your library. They can only call functions included in your library's public API since they use it in the same manner as any other code.

 extern crate adder;
 #[test]
 fn it_adds_two() {
    assert_eq!(4, adder::add_two(2));
 }

Mocking
Mocking is a practice in unit testing. In mocking, you create fake objects, called mocks, from real objects for testing purposes. These mocks simulate the behavior of the real object as much as it needs to. is this correct.

Reasons for Mocking

Control over test environment
Isolation of components for unit testing
Improved test stability and reliability
Efficiency and speed
Enabling testing of unavailable or incomplete components

mockall crate is most popular mocking library in the Rust ecosystem:

[dependencies]
mockall = "0.11"

use mockall::{automock, predicate::*};

#[automock]
pub trait Adder {
    fn add(&self, a: i32, b: i32) -> i32;
}

pub fn add_with_logger(adder: &dyn Adder, a: i32, b: i32) -> i32 {
    let result = adder.add(a, b);
    println!("Adding {} + {} = {}", a, b, result);
    result
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_with_logger() {
        let mut mock = MockAdder::new();
        mock.expect_add()
            .with(eq(2), eq(3))
            .returning(|a, b| a + b);

        let result = add_with_logger(&mock, 2, 3);
        assert_eq!(result, 5);
    }
}

Understanding Rust Ownership

Sureni Dhanasekara — Tue, 22 Apr 2025 10:35:25 +0000

ownership is a core concept that determines how memory is managed at runtime, guaranteeing memory safety without needing a garbage collector. Each value in Rust has a single owner (a variable), and when the owner goes out of scope, the value is dropped (memory is freed). This system prevents memory leaks and dangling pointers by ensuring that there's always a clear responsibility for cleaning up memory

Ownership Rules

Each value in Rust has a variable that’s called its owner.
There can be only one owner at a time.
When the owner goes out of scope, the value will be dropped.

Example: Ownership Transfer

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership moves from s1 to s2

    println!("{}", s1); // ❌ ERROR: s1 is no longer valid
}

reason for S1 is not valid is String is heap-allocated, and Rust moves ownership to avoid double-free errors. But if you want to keep both s1 and s2 are valid then can use clone

let s1 = String::from("hello");
let s2 = s1.clone(); // now both s1 and s2 are valid

println!("{}", s1); 
println!("{}", s2);

Ownership can be returned

fn give_ownership() -> String {
    String::from("Rust")
}

fn main() {
    let s = give_ownership(); // s gets ownership
    println!("{}", s);        // Works fine
}

Or pass in a value and return it back

fn take_and_return(s: String) -> String {
    s // return ownership
}

fn main() {
    let name = String::from("Rust");
    let name = take_and_return(name); // ownership moves and returns
    println!("{}", name); // Still valid
}

Copy Types vs Move Types

Simple types like integers are Copy types (stack-based):
Complex types like String, Vec, etc., are Move types (heap-based).

simple scalar values can be Copy, and nothing that requires allocation or is some form of resource is Copy. Here are some of the types that are Copy:

• All the integer types, such as u32.
• The Boolean type, bool, with values true and false.
• The character type, char.
• All the floating point types, such as f64.
• Tuples, but only if they contain types that are also Copy. For example, (i32, i32) is Copy, but (i32, String) is not.

References and Borrowing
In Rust, borrowing is when you let someone use a value without taking ownership.

Instead of moving ownership (which makes the original variable unusable), you can borrow it using references.

fn print_name(name: &String) {
    println!("Name: {}", name);
}

fn main() {
    let name = String::from("martin");
    print_name(&name);       // borrowed using & (immutable reference)
    println!("{}", name);    // still usable here
}

Types of Borrowing
Immutable Borrow (&T)

Allows read-only access
Any number of immutable borrows allowed at the same time

fn show(val: &String) {
    println!("Value: {}", val);
}

Mutable Borrow (&mut T)

Allows write access
Only one mutable borrow is allowed at a time

fn change(val: &mut String) {
    val.push_str(" Rocks!");
}

fn main() {
    let mut msg = String::from("Rust");
    change(&mut msg);           // mutable borrow
    println!("{}", msg);        // Rust Rocks!
}

Borrowing Rules

You can have either one mutable reference or any number of immutable references, but not both at the same time
References must always be valid (no dangling pointers!)

Why Borrowing Matters

Rust avoids data races and null/dangling pointers
You don’t need to manually manage memory
It prevents bugs at compile time, not at runtime

Rust Generics and Traits

Sureni Dhanasekara — Sun, 20 Apr 2025 12:10:44 +0000

Generics allows you to write versatile and reusable codes which are in multiple types without duplications. Simply Instead of writing separate functions for i32, f64, and String, you write one generic function that works with all of them. They are denoted by angle brackets (<>)

Why Use Generics

Code reusability: Write once, use for any type.
Type safety: Compiler checks for correct types at compile time.
Performance: No runtime overhead

Problem Example: Finding the Largest Item in a List

Without generics, your code looks like this:

fn largest_i32(list: &[i32]) -> &i32 {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> &char {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest_i32(&number_list);
    println!("The largest number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest_char(&char_list);
    println!("The largest char is {result}");
}

In here we can see it duplicated code for largest_i32 and largest_char. We can use generics in this code like as follows:

Rewriting with Generics

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {result}");

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {result}");
}

T: PartialOrd is a trait bound that ensures the type supports comparison using >.

This function now works for i32, char, and any type implementing PartialOrd.

Where Are Generic Types Used?

Functions

fn identity<T>(x: T) -> T {
    x
}

Structs

struct Point<T> {
    x: T,
    y: T,
}

Enums

enum Option<T> {
    Some(T),
    None,
}

Traits & Implementations

impl<T: std::fmt::Debug> Point<T> {
    fn show(&self) {
        println!("{:?}, {:?}", self.x, self.y);
    }
}

Methods With Multiple Generics

struct Pair<T, U> {
    first: T,
    second: U,
}

Monomorphization
Rust uses a process called monomorphization during compilation:

For each concrete type used with a generic, it generates a version of the function or struct for that type.
This means no runtime overhead, unlike Java or C++ templates.

Generic Function:
fn identity<T>(x: T) -> T

Used with:
- identity(10)
- identity("hello")

→ Compiler generates:
- fn identity_i32(x: i32) -> i32
- fn identity_str(x: &str) -> &str

What Are Traits?
In Rust, traits are like interfaces in other languages. They define behavior that types can implement. Traits help constrain generics to ensure type safety and functionality.

Defining and Implementing Traits

trait Greet {
    fn greet(&self) -> String;
}

struct Person;

impl Greet for Person {
    fn greet(&self) -> String {
        "Hello!".to_string()
    }
}

Default Implementations

trait Farewell {
    fn goodbye(&self) -> String {
        "Goodbye!".to_string()
    }
}

Using where Clauses for Readability
Instead of:

fn process<T: Greet, U: Farewell>(t: T, u: U)

Use:

fn process<T, U>(t: T, u: U)
where
    T: Greet,
    U: Farewell,
{
    println!("{} {}", t.greet(), u.goodbye());
}

Common Mistakes with Generics

Forgetting Trait Bounds
If you try to compare or print generic types without proper trait bounds like PartialOrd, Debug, or Display, you'll get compiler errors.
Overcomplicating Generics
Not everything needs to be generic. Use when there's clear duplication or type flexibility needed.
Type Inference Limits
Sometimes the compiler can't infer the type, especially in complex chains. You might need to explicitly annotate types.

Understanding Crates in Rust

Sureni Dhanasekara — Sat, 19 Apr 2025 11:36:14 +0000

Crate is a compilation unit which serve as packages of rust code. This can be reused, share and publish. Whether you're consuming powerful third-party libraries or crafting your own, understanding crates is essential to becoming an effective Rustacean. With a vibrant ecosystem and a robust toolchain, Rust crates allow developers to build fast, reliable, and modern software one crate at a time. Crates are not just an organizational tool they define how your code is compiled and reused.

Reusable : Once you write a crate (especially a library crate), it can be used in multiple projects. Example - You write a math_utils crate with useful math functions. You can then use that same crate in other projects or even publish it for others.
Shareable : Using tools like crates.io, you can share your crate with the entire Rust ecosystem. Others can add your crate as a dependency and start using it instantly.
Modular : A crate helps break your project into smaller logical components.Instead of one giant file, you can create organized modules and expose only what’s necessary to users of your crate.
Scalable : Large applications in Rust are often made up of multiple crates, sometimes managed using a workspace.This allows teams to build and test parts of the project independently.

There are two primary types of crates:

Binary crate - This Produce an executable program. They have an entry point (fn main()). This is the default crate. When we use rustc main.rs then it treated as binary crate. When create project by using cargo (Rust’s build system and dependency manager) it default create binary crate.

cargo new my_app

Library crate - Provide functionality to be used by other crates. They don’t have a main() function. We can use --crate-type lib to convert binary crate to library crate. If you want to create project with library crate use following code.

cargo new my_lib --lib

Crates can be reused across projects, and the Rust community shares tens of thousands of crates via crates.io(The official registry for Rust crates), the official package registry.One such crate is holiday-checker, which I published to help developers easily check for holidays in their applications. You can find the source code on GitHub.

To use an external crate, add it to your Cargo.toml under [dependencies]:

[dependencies]
rand = "0.8"    # Use the rand crate for randomness

And then add it to your code:

use rand::Rng;

fn main() {
    let mut rng = rand::thread_rng();
    let n: u8 = rng.gen_range(1..=10);
    println!("Random number: {}", n);
}

Rust crates support unit and integration testing natively. Inside any crate:

// src/lib.rs
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}

Run tests with:

cargo test

You can share your crate with the world by publishing it to crates.io:

Create an account on crates.io
Add metadata to Cargo.toml:

[package]
name = "my_crate"
version = "0.1.0"
authors = ["Your Name <you@example.com>"]
edition = "2021"
license = "MIT OR Apache-2.0"
description = "A useful utility library"
repository = "https://github.com/your/repo"

Authenticate:

cargo login <your-api-token>

Publish:

cargo publish

holiday-checker crate : https://crates.io/crates/holiday_checker
GitHub Repo : https://github.com/surenidh/rust/tree/holiday-crate/holiday_checker