A Simple Function

Open a terminal and create a fresh binary project with Cargo. This gives you a main.rs ready to edit.

cargo new simple_function
cd simple_function

Cargo generates a src/main.rs that prints “Hello, world!”. We'll replace that with our own function shortly.

Replace src/main.rs with the following:

fn is_divisible(num: i32, divisor: i32) -> bool {
    num % divisor == 0
}
fn main() {
    let result = is_divisible(10, 2);
    println!("10 is divisible by 2: {}", result);
}

The function is_divisible takes two signed 32‑bit integers and returns a boolean. It uses the remainder operator % — if the remainder is zero, the divisor divides the number evenly. Notice the lack of a semicolon after num % divisor == 0; that expression becomes the return value.

main stores the boolean and prints it with the println! macro. The ! is part of the macro name and must always be present when you call it.

Compile and run to see the function in action:

cargo run

You should see:

10 is divisible by 2: true

The function computes a value, and main displays it. Everything is wired together, but the input is hard‑coded. Next, you’ll make sure the logic is solid with tests.

Add a test module at the bottom of src/main.rs. The #[cfg(test)] attribute tells the compiler to include this code only when running tests.

#[cfg(test)]
mod tests {
    use super::is_divisible;
    #[test]
    fn divisor_divides_evenly() {
        assert!(is_divisible(10, 2));
    }
    #[test]
    fn divisor_does_not_divide_unevenly() {
        assert!(!is_divisible(10, 3));
    }
    #[test]
    #[should_panic]
    fn divisor_zero_causes_panic() {
        is_divisible(10, 0);  // division by zero panics at runtime
    }
}

The first two tests check the happy paths. The third one confirms that dividing by zero panics (Rust does not guard against it in debug builds for i32). The #[should_panic] attribute tells the test runner that a panic is the expected outcome — without it, the test would fail.

The line use super::is_divisible; brings the function from the parent module into scope, because the test module is a child of main.

Run all tests with:

cargo test

The output confirms that all three tests pass. You’ll see something like:

running 3 tests
test tests::divisor_zero_causes_panic ... ok
test tests::divisor_does_not_divide_unevenly ... ok
test tests::divisor_divides_evenly ... ok
test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Now modify main to read two numbers from the arguments passed to the program. Rust’s standard library provides std::env::args() for this.

Update src/main.rs to the following — keep the is_divisible function and the test module unchanged:

use std::env;
fn is_divisible(num: i32, divisor: i32) -> bool {
    num % divisor == 0
}
fn main() {
    let args: Vec<String> = env::args().collect();
    if args.len() < 3 {
        eprintln!("Usage: {} <num> <divisor>", args[0]);
        return;
    }
    let num: i32 = args[1].parse().unwrap();
    let divisor: i32 = args[2].parse().unwrap();
    println!(
        "{} is divisible by {}: {}",
        num,
        divisor,
        is_divisible(num, divisor)
    );
}

The env::args() iterator yields the program name as the first element, followed by any arguments you supply. We collect them into a Vec<String> and check the length before indexing. If the user provides fewer than two arguments, we print a usage message and return early.

parse() converts a string slice into the target type; we use i32. The calls to unwrap() extract the value or panic if parsing fails.