123. Functions and expressions

The ternary you never liked

You want a label that depends on a number. In TypeScript:

let label: string;
if (n < 0) {
  label = 'negative';
} else {
  label = 'not negative';
}

Four lines, a variable that has to be let, and a moment where it holds nothing. So you write a ternary instead: const label = n < 0 ? 'negative' : 'not negative';. The ternary exists because if is a statement. It does something but has no value.

Chapter 31 drew that line through Drip’s own grammar: expressions produce values, statements don’t. Rust moves most things to the expression side:

let label = if n < 0 {
    "negative"
} else {
    "not negative"
};

No ternary, no mut, and label is never empty.

Blocks have values

Any { ... } block is an expression. Its value is its last expression, written without a semicolon:

let y = {
    let a = 3;
    a + 1
};
// y is 4

let a = 3; is a statement, and it ends with a semicolon. a + 1 has none, so it is the block’s value. Put a semicolon after it and it becomes a statement too. The block then has the value (), the unit value, Rust’s “nothing” (much like void).

let itself is a statement, so let x = let y = 6; is an error. In JavaScript, x = y = 6 works, because assignment is an expression.

Both branches of an if must agree:

error[E0308]: `if` and `else` have
  incompatible types
 --> f2.rs:3:31
  |
3 |     let s = if b { 1 } else { "no" };
  |                    -          ^^^^
  |                    |  expected integer,
  |                    |  found `&str`
  |                    expected because
  |                    of this

(rustc 1.97, wrapped to fit. b is a bool.) TypeScript would happily give s the type number | string. Rust wants one type.

Functions

You’ve seen one already. Here is the full shape:

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

• fn, a snake_case name, and parameters, each with its type. A function’s parameter types are never inferred.
• -> i32 is the return type. Leave it out and the function returns ().
• The body is a block, so its final expression is the return value. a + b with no semicolon is the return.

return still exists, for leaving early:

fn safe_div(a: i32, b: i32) -> i32 {
    if b == 0 {
        return 0;
    }
    a / b
}

Idiomatic Rust uses return only for early exits, and lets the last expression do the rest^[1]. Two more differences from TypeScript: a function can be called from code above its definition, and there are no default or optional parameters.

Watching a value flow out

Here is chapter 1’s clamp, the Rust way. It has no return and no variables, just one if expression whose value becomes the function’s:

fn clamp(x: i32, lo: i32, hi: i32) -> i32 {
    if x < lo {
        lo
    } else if x > hi {
        hi
    } else {
        x
    }
}
 
fn main() {
    let r = clamp(15, 0, 10);
    println!("{r}");
}

The last step is the famous mistake. Here it is for real, in a smaller function:

fn inc(x: i32) -> i32 {
    x + 1;
}

error[E0308]: mismatched types
 --> f1.rs:1:19
  |
1 | fn inc(x: i32) -> i32 {
  |    ---            ^^^ expected `i32`,
  |    |                  found `()`
  |    |
  |    implicitly returns `()` as its body
  |    has no tail or `return` expression
2 |     x + 1;
  |          - help: remove this semicolon
  |            to return this value

The compiler even points at the semicolon. When you see “expected i32, found ()”, look for a semicolon at the end of a block.

fn clamp(x: i32, lo: i32, hi: i32)
    -> i32 {
    if x < lo {
        lo
    } else if x > hi {
        hi
    } else {
        x
    }
}

fn main() {
    let y = {
        let a = 3;
        a + 1
    };
    println!("{y}");
    println!("{}", clamp(15, 0, 10));

    let n = -2;
    let label = if n < 0 {
        "negative"
    } else {
        "not negative"
    };
    println!("{label}");
}

Loops look as you’d expect, minus the parentheses: while n > 0 { ... }. Rust has no C-style for (let i = 0; ...) loop. Chapter 134 covers its for.

Your turn

fn grade(score: u32) -> char {
    todo!()
}

fn steps(n: u64) -> u32 {
    todo!()
}

What you learned

• Rust is expression-oriented: blocks and if produce values. A block’s value is its final expression, without a semicolon.
• A trailing ; turns an expression into a statement, giving (). “expected i32, found ()” usually means a stray semicolon.
• Both branches of an if must have the same type, and an if used as a value needs an else.
• Functions: fn name(p: T) -> R { ... }. Parameter types are required. The final expression is the return value; return is for early exits.

Next comes the idea that makes Rust Rust: who owns a value, and when it goes away.