Variables, functions and control flow

Four pieces for giving instructions

A useful program needs to remember data, apply rules, make decisions, and repeat work. Before looking at Rust syntax, we can arrange those tasks into four pieces:

01 · VariableStorean amount of energy
02 · FunctionCalculatehow to transform it
03 · ConditionDecidewhether energy remains
04 · LoopRepeatthe operation for several turns

Rust expresses those four ideas with variables, functions, if, and loops. You do not need to know how each value is stored in memory yet: here, the goal is to learn how to read the program’s path.

STATE · energyinitial value: 4
RULE · let mutchange is declared
RESULT · variable readyit can be updated later

01 / 04LET · IMMUTABLE BY DEFAULT

A variable gives a value a name

let creates a variable. Rust considers it immutable by default: after let initial_energy = 4, that name will keep representing the same value. This rule prevents accidental changes.

When state really needs to change, it is declared with mut. In the example, energy starts at 4 and loses one unit. The abbreviated instruction shown here subtracts one unit and stores the new result.

lib.rsCompiles↗

/// Creates an energy reserve and consumes one unit.
#[must_use]
pub fn prepare_energy() -> i32 {
    let initial_energy = 4;
    let mut energy = initial_energy;
    energy -= 1;
    energy
}

// Playground entry point for this example.
fn main() {
    println!("available energy: {}", prepare_energy());
}

Result

A function transforms an input

A function gathers a rule under one name. In boost(3), the 3 reaches the energy parameter. The : i32 annotation says it is a 32-bit integer, and -> i32 promises that the function will return another integer of the same type.

The last line is an expression: it produces a value. Because it has no semicolon, that value is returned. Adding ; would turn it into a statement and break the return contract.

lib.rsCompiles↗

/// Returns twice the received energy.
#[must_use]
pub const fn boost(energy: i32) -> i32 {
    energy * 2
}

// Playground entry point for this example.
fn main() {
    println!("boosted energy: {}", boost(3));
}

Result

if evaluates a Boolean condition

if chooses a branch from a Boolean value: true or false. Rust does not treat numbers or text as implicit conditions; energy > 0 must explicitly produce a bool.

If the condition is true, the first block runs. If it is false, else runs. Because if is also an expression, both branches can produce the value returned by the function.

lib.rsCompiles↗

/// Decides whether the workshop can run another turn.
#[must_use]
pub const fn can_continue(energy: i32) -> bool {
    if energy > 0 { true } else { false }
}

// Playground entry point for this example.
fn main() {
    println!("can continue: {}", can_continue(2));
}

Result

for visits every value in a range

for turn in 1..=3 visits the inclusive range 1, 2, 3. On each pass, turn receives the next value and the block runs again. The program checks energy before subtracting, so it never drops below zero.

The range 1..3, without =, would exclude the end and produce only 1, 2. This small difference changes how many times the body runs.

lib.rsCompiles↗

/// Runs three turns and shows how the energy changes.
pub fn run_turns(initial_energy: i32) {
    let mut energy = initial_energy;

    for turn in 1..=3 {
        if energy > 0 {
            energy -= 1;
        }

        println!("turn {turn}: {energy} remaining");
    }
}

// Playground entry point for this example.
fn main() {
    run_turns(3);
}

Result

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Inference and annotations

Rust needs to know the type of every value, but it can often infer it:

Code	Type Rust recognizes	What it represents
`let energy = 4;`	integer, usually `i32`	a number without decimals
`let temperatura = 18.5;`	decimal, usually `f64`	a number with decimals
`let activo = true;`	`bool`	true or false
`let simbolo = 'R';`	`char`	one Unicode character

You can write let energy: i32 = 4; when the type choice matters or when you want to make it visible. You do not need to annotate every variable.

Choosing a loop

Form	Use it when…	Key idea
`for`	you have a sequence or range to visit	advances automatically through every element
`while`	you need to repeat while a condition is true	checks the condition before each pass
`loop`	you want to repeat until you choose to leave with `break`	has no implicit exit condition

In this introduction you will practise for, the most direct option when a range describes the number of steps. Module 1 will go deeper into while, loop, break, continue, and loop labels.

Before running: predict

For remaining_energy(3, 2), the variable starts at 3. The 0..2 range produces two passes: after the first, 2 remains; after the second, 1 remains. For remaining_energy(2, 5), the final three passes still check the condition, but no longer subtract because energy has reached 0. The exercise uses non-negative initial energy and turn counts.

Predicting the state pass by pass is a simple way to review a loop before asking the compiler to run it.

Objective

Complete remaining_energy for non-negative inputs. Each turn consumes one unit while energy remains. The result must not drop below zero, and zero turns must preserve the initial energy.

Implement

Replace `todo!` with `energy -= 1;`.

Complete the structured body: subtract one unit when the condition allows entry.

/// Calculates the energy remaining after several turns.
pub fn remaining_energy(initial_energy: i32, turns: i32) -> i32 {
    let mut energy = initial_energy;
    for _turn in 0..turns {
        if energy > 0 {
            todo!("subtract one unit of energy");
        }
    }
    energy
}

Check

Run three visible cases and use the diagnostic to correct the code.

Visible tests

subtracts, stops at zero, and accepts zero turns

Compiler—

Modify the code before running the tests.

Help

View progressive hints or compare with the solution.

Commented solutionSolution↗

/// Calculates the remaining energy without allowing a non-negative input to drop below zero.
#[must_use]
pub fn remaining_energy(initial_energy: i32, turns: i32) -> i32 {
    let mut energy = initial_energy;

    for _turn in 0..turns {
        if energy > 0 {
            energy -= 1;
        }
    }

    energy
}

// Playground entry point for this example.
fn main() {
    println!("{}", remaining_energy(3, 2));
    println!("{}", remaining_energy(2, 5));
    println!("{}", remaining_energy(4, 0));
}

Result

Summary

let creates immutable variables by default; let mut permits explicit changes.
Rust can infer basic types, while an annotation such as : i32 fixes the choice.
A function declares parameter and return types; its final expression returns the value.
if requires a Boolean condition and runs exactly one of its branches.
for visits sequences and ranges; .. excludes the end and ..= includes it.
while repeats according to a condition and loop continues until a break; both are covered in depth later.

Sources

The Rust Programming Languagech03-01–ch03-05 · Klabnik, Nichols, Krycho y la comunidad de Rust
Rust by Examplevariable_bindings/functions/flow_control
Comprehensive Rustbasic-syntax/control-flow-basics · Geisler y colaboradores (Google)

Variables, functions and control flow

Four pieces for giving instructions

Inference and annotations

Choosing a loop

Before running: predict

Make the energy last for as many turns as possible.

Implement

Calculate remaining energy

Check

Help

Summary

Sources