Parameters

Learn function parameters and their types.

Parameters

Parameter types are always written explicitly; the compiler doesn't infer types in function signatures. This makes the signature a readable contract on its own:

fn alan(en: f64, boy: f64) -> f64 {
    en * boy
}

fn tekrarla(metin: &str, kez: usize) {
    for _ in 0..kez {
        println!("{metin}");
    }
}

Are arguments copied?

Small types such as i32, f64 and bool are copied when passed as arguments. Heap types such as String and Vec are moved: the function becomes their owner and the caller can no longer use them. To avoid that, a reference (&String, &str) is passed; you'll see the details in the ownership lesson.

Exercise Repeat

Write the fn tekrarla(metin: &str, kez: usize) function; it prints the text kez times on one line separated by spaces (print! + println!() at the end). Call tekrarla("go", 3).

Show example solution

fn tekrarla(metin: &str, kez: usize) {
    for _ in 0..kez {
        print!("{metin} ");
    }
    println!();
}

fn main() {
    tekrarla("go", 3);
}

Test yourself

Why doesn't <code>fn ikiye(n) -> i32 { n * 2 }</code> compile?
- The parameter type is missing
- The return type is wrong
- return is missing
- It compiles
Show answer

The parameter type is missing — Function parameters need a type annotation: fn ikiye(n: i32) -> i32. Without return, the last expression is the return value.

Parameter type

fn kup(n: ____) -> i64 {
    n * n * n
}

Show answer

fn kup(n: i64) -> i64 {
    n * n * n
}

Signature and meaning

fn f(a: i32, b: i32)

Two i32 parameters
fn f(s: &str)

Borrowed text
fn f(s: String)

Takes ownership
fn f() -> f64

No parameters, returns f64

Next lesson: Return value

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies