Funzioni in

Informazioni su Funzioni

Le funzioni sono corpi di codice che contengono una o più istruzioni o espressioni. Una funzione può restituire facoltativamente un valore.

Lo stile di Rust prevede l'uso dello snake case per il nome di una funzione; nella definizione, il nome è preceduto dalla parola chiave fn. Per esempio

fn do_nothing() {}

Le parentesi tonde racchiudono zero o più parametri, separati da virgole. Un parametro è un'associazione a un valore di un tipo particolare, che viene passato alla funzione. Anche se non ci sono parametri, le parentesi sono comunque necessarie nella definizione della funzione. Il valore effettivo passato a un parametro si chiama argomento.

La combinazione di parametri e valore restituito è nota come firma della funzione. La firma di una funzione richiede che ogni parametro abbia il tipo annotato.

Le parentesi graffe racchiudono il corpo della funzione: le sue istruzioni ed espressioni. Anche se la funzione non contiene istruzioni o espressioni, le parentesi graffe sono comunque necessarie per la definizione della funzione.

Nell'esempio seguente la funzione riceve un parametro di tipo i32, lo associa al nome value e lo stampa.

fn print_integer(value: i32) {
    println!("{value:?}");
}

Osserva la definizione del parametro. Ogni parametro è definito nel formato name: Type.

Una funzione può anche restituire un valore. Per impostazione predefinita, viene restituito l'output dell'espressione finale. Nell'esempio seguente la funzione ha un parametro i32 e restituisce il suo doppio.

fn double_integer(value: i32) -> i32 {
    value * 2
}

Il -> i32 indica che la funzione restituisce un i32. A differenza dei parametri, il valore restituito non ha un nome.

È possibile uscire anticipatamente da una funzione con la parola chiave return, così:

fn long_function() -> i32 {
    let some_condition = false;
    // code snipped
    if (some_condition) {
        return 0;
    }
    // more code snipped
    42
}

const fn si usa per definire una funzione costante, che può essere valutata in fase di compilazione.

const fn compute_data_checksum() -> u128 {
  const DATA: &[u8] = include_bytes!("my_big_data_file");
  // checksum implementation is left as an exercise for the reader
}

/// This checksum is used to validate that the user has not tampered with proprietary configuration.
pub const DATA_CHECKSUM: u128 = compute_data_checksum();

Poiché le funzioni costanti possono essere valutate in fase di compilazione, hanno alcune restrizioni che le funzioni normali non hanno. In particolare, una const fn può chiamare solo altre funzioni anch'esse contrassegnate come const. Il mancato rispetto di questa restrizione provoca un errore di compilazione.

const fn multiply_integer(value: i32) -> i32 {
    use std::time::SystemTime;
    if SystemTime::now().elapsed().unwrap().as_nanos() == 0 { // this line errors
        value * 2
    } else {
        value * 3
    }
}

Esistono le funzioni anonime, trattate nell'argomento closures.