ps4 - rust traduccion

¿Rust tiene soporte para funciones que devuelven múltiples valores?

Question

¿Rust tiene soporte nativo para funciones que devuelven valores múltiples como Go?

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

Parece que podríamos usar una tupla para simularla. Rosetta Code presenta cómo devolver múltiples valores en diferentes idiomas, pero no vi Rust.

Answer 1

En Rust no tienes que usar la palabra clave return :

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

Answer 2

En Rust puedes devolver una tupla con más de un valor:

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

Un idioma que devuelve más que un valor probablemente esté emulando esto con una tupla u otra estructura de datos, ya que en la mayoría de las convenciones de llamadas el valor de retorno está en un solo registro.

No se puede hablar de Go, pero hay muchas posibilidades de que solo estén emulando los múltiples valores dentro de una tupla y en tiempo de compilación, lo que obliga a administrar las devoluciones.

No veo ningún problema con la oxidación al hacer esto, ya que así es como OCaml o Haskell (y otros) lo administran, y aplican la verificación de tipos en los valores de retorno (o tupla), por lo que es probable que algo vaya mal. La forma más común de administrar los valores de retorno es deconstruir la tupla en dos o más enlaces ( let (a, b) = tuple_2(); ).

Solo mis dos centavos, siéntete libre de corregirme.

Answer 3

Este es un ejemplo que muestra cómo puede asignar fácilmente la tupla de retorno a variables separadas.

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

let (a, b) = addsub(1, 2);

Answer 4

Esto funciona para mí:

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

Es básicamente el mismo que en Go, pero se requieren los paréntesis.