Questo è quello che ho finora.Come si restituiscono più valori e li si assegnano alle variabili mutabili?
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)
Non è possibile; non c'è sintassi per aggiornare "più di una variabile mutabile" con un singolo compito. Naturalmente si può fare
let newX, newY = Swap(x,y)
x <- newX
y <- newY
Speravo in una risposta più favorevole, ma almeno questa è corretta. Le incoerenze di Sigh, F # stanno rapidamente diventando un dolore al mio fianco. Mi rendo conto che sto spingendo contro i confini, ma non dovrei picchiarli così presto. –
Non sono sicuro di definire come "limite" l'idea che i costrutti linguistici che sono scoraggiati abbiano una sintassi meno conveniente dei costrutti preferiti. Rendere le migliori pratiche anche le più convenienti mi sembra un'idea intelligente. –
@Joel. Non è questa la definizione di confine? Se stavo usando la sintassi preferita non avrei usato quel termine. –
Il codice che avete commentato non funziona perché quando si scrive "x, y" si crea una nuova tupla che è un valore immutabile, quindi non può essere aggiornato. Si potrebbe creare una tupla mutevole e quindi sovrascrivere con il risultato della funzione di scambio, se si desidera:
let mutable toto = 5, 10
let swap (x, y) = y, x
toto <- swap toto
Il mio consiglio sarebbe quello di indagare il lato immutabile di F #, guardare i modi è possibile utilizzare strutture immutabili per raggiungere ciò che avresti fatto in precedenza utilizzando valori mutabili.
Rob
Questo è ciò che è probabilmente desiderato –
Se si desidera generalizzare questo, è ancora necessario decomprimere la tupla mutabile indietro ai valori originali. Quindi usare una tupla mutabile è uno spreco. –
Non mi è chiaro il motivo per cui è necessario decomprimere o anche sostituire i nuovi xey nella variabile originale. In qualsiasi mondo reale exmaple si dovrebbe semplicemente scrivere "lascia x ', y' = swap x y" e usare direttamente x e y prime. – Robert
di espandere la risposta di 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
rende sia le variabili e la tupla mutabile.
Non funziona. Quando stampi xey, vedrai che non sono cambiati. Rendere xy mutabile era solo una falsa pista, dato che avresti potuto passare altrettanto facilmente nelle variabili originali. –
Corretto, la xey non viene aggiornata. –
F # ha "per riferimento" parametri, proprio come C#, in modo da poter scrivere una funzione di scambio classico simile:
let swap (x: byref<'a>) (y: byref<'a>) =
let temp = x
x <- y
y <- temp
let mutable x,y = 1,2
swap &x &y
sto imparando Python e immaginare quanto freddo F # potrebbe essere se permettiamo: 'a, b <- b, a', 'x. [a], x. [b] <- x [b], x [a]' In modo che 'swap' non sia più necessario. – colinfang