Esto es lo que tengo hasta ahora.¿Cómo devuelves valores múltiples y los asignas a variables variables?
let Swap (left : int , right : int) = (right, left)
let mutable x = 5
let mutable y = 10
let (newX, newY) = Swap(x, y) //<--this works
//none of these seem to work
//x, y <- Swap(x, y)
//(x, y) <- Swap(x, y)
//(x, y) <- Swap(x, y)
//do (x, y) = Swap(x, y)
//let (x, y) = Swap(x, y)
//do (x, y) <- Swap(x, y)
//let (x, y) <- Swap(x, y)
No puede; no hay sintaxis para actualizar 'más de una variable mutable' con una sola tarea. Por supuesto que puede hacer
let newX, newY = Swap(x,y)
x <- newX
y <- newY
Esperaba una respuesta más favorable, pero al menos esta es la correcta. Suspiro, las inconsistencias de F # se están convirtiendo rápidamente en un dolor en mi costado. Me doy cuenta de que estoy presionando contra los límites, pero no debería golpearlos tan pronto. –
No estoy seguro de que caracterice como un "límite" la idea de que los constructos de lenguaje que se desalientan tienen una sintaxis menos conveniente que los constructos preferidos. Hacer las mejores prácticas y las más convenientes me parece una idea inteligente. –
@Joel. ¿No es esa la definición de límite? Si estuviera usando la sintaxis preferida, no habría usado ese término. –
El código que ha comentado que no funciona porque cuando se escribe "x, y" se crea una nueva tupla que es un valor inmutable, por lo que no se puede actualizar. Se puede crear una tupla mutable y luego escriba el resultado de la función de intercambio si quieres:
let mutable toto = 5, 10
let swap (x, y) = y, x
toto <- swap toto
Mi consejo sería investigar el lado inmutable de F #, mirar las formas que puede utilizar las estructuras inmutables a logra lo que previamente hubieras hecho usando valores mutables.
Rob
Esto es lo que probablemente se desee –
Si desea generalizar esto, aún debe desempaquetar la tupla mutable de nuevo a los valores originales. Entonces realmente usar una tupla mutable es un desperdicio. –
No me queda claro por qué necesita descomprimir o incluso reemplazar las nuevas xey en la variable original. En cualquier mundo real, simplemente escribirías "let x ', y' = swap x y" y usarías directamente x y y prime. – Robert
Para ampliar la respuesta de Robert:
let swap (x : int, y : int) = y, x
let mutable x = 5
let mutable y = 10
let mutable xy = x, y
xy <- swap xy
hace que tanto las variables y la tupla mutable.
No funciona. Cuando imprima xey, verá que no cambiaron. Convertir a xy mutable fue solo una queja, ya que podrías haber pasado fácilmente las variables originales. –
Correcto, la x y la y no se actualizan. –
F # tiene "por referencia" parámetros simplemente como C#, por lo que puede escribir una función de intercambio clásica parecida:
let swap (x: byref<'a>) (y: byref<'a>) =
let temp = x
x <- y
y <- temp
let mutable x,y = 1,2
swap &x &y
estoy aprendiendo Python e imaginar cómo enfriar F # podría ser si permitimos que: 'a, b <- b, a', 'x. [a], x. [b] <- x [b], x [a]' De modo que 'swap' ya no es necesario. – colinfang