Rust supporta le funzioni che restituiscono più valori?

Question

Rust ha il supporto nativo per funzioni che restituiscono valori multipli come Go?

func addsub(x, y int) (int, int) { 
    return x + y, x - y 
} 

Sembra che potremmo usare una tupla per simularlo. Rosetta Code introduce come restituire più valori in diverse lingue, ma non ho visto Rust.

Answer 1

questo funziona per me:

fn addsub(x: isize, y: isize) -> (isize, isize) { 
    return (x + y, x - y); 
} 

E 'fondamentalmente lo stesso come in Go, ma sono necessarie le parentesi.

Answer 2

A Rust è possibile restituire una tupla con più di un valore:

fn my_func() -> (u8, bool) { 
    (1, true) 
} 

Un linguaggio di tornare più di un valore non è probabilmente emulando questo con una tupla o di un'altra struttura di dati, come nella maggior parte delle convenzioni di chiamata del valore di ritorno è in un solo registro.

Non si può parlare di Go, ma ci sono alte probabilità che stiano semplicemente emulando i valori multipli all'interno di una tupla e in fase di compilazione obbligandoti a gestire i ritorni.

Non vedo alcun problema con la ruggine, questo è il modo in cui ocaml o haskell (e altri) lo gestiscono, e applicano il controllo del tipo nei valori di ritorno (o tupla), quindi è probabile che qualcosa vada male. Il modo più comune per gestire i valori di ritorno è la decostruzione della tupla in due o più associazioni (let a, b = tuple_2()).

Solo i miei due centesimi, sentiti libero di correggermi.

Answer 3

In Ruggine non c'è bisogno di utilizzare la ritorno parola chiave:

fn addsub(x: isize, y:isize) -> (isize, isize) { 
    (x + y, x - y) // use tuple to simulate it 
}