Functions

Functions in TypeScript vs Rust

TypeScript functions are defined with function or arrow syntax, with optional type annotations. In Rust, all functions are defined with fn, and all parameter and return types are required — the compiler never infers them across function boundaries. This keeps function signatures as explicit, readable contracts.

Syntax comparison

TypeScript uses : Type for parameters and : ReturnType after the closing paren. Rust uses the same : Type syntax for parameters and -> ReturnType after the param list.

// TypeScript
function add(a: number, b: number): number {
  return a + b;
}

// Rust
fn add(a: i32, b: i32) -> i32 {
    a + b   // no semicolon — this is the return value
}

Notice the last line has no semicolon. In Rust, a block’s final expression (without ;) is implicitly returned. Adding a semicolon turns it into a statement that returns () (unit), which would be a type error here.

function add(a: number, b: number): number {
  return a + b;
}

function greet(name: string): string {
  return `Hello, ${name}!`;
}

console.log(add(3, 4));      // 7
console.log(greet("Alice")); // Hello, Alice!

fn add(a: i32, b: i32) -> i32 {
    a + b  // last expression, no semicolon = return value
}

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    println!("{}", add(3, 4));      // 7
    println!("{}", greet("Alice")); // Hello, Alice!
}

Try it

Open in Rust Playground

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

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn main() {
    let sum = add(3, 4);
    println!("3 + 4 = {sum}");
    let msg = greet("Rustacean");
    println!("{msg}");
}

🟦 Expression-oriented language

In TypeScript, if and blocks are statements — they don’t produce values. You need the ternary ? : to produce a value conditionally. Rust is an expression-oriented language: if, match, and block expressions all produce values.

// No ternary needed in Rust — if is an expression
let label = if score >= 60 { "pass" } else { "fail" };

This also means function bodies don’t need a return statement for the common case. The last expression in the function body is automatically returned. You still can use return for early returns.

fn absolute(n: i32) -> i32 {
    if n < 0 { -n } else { n }  // the whole if is the return value
}