C'est ce que j'ai jusqu'ici.Comment renvoyez-vous plusieurs valeurs et attribuez-les à des variables mutables?
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)
Vous ne pouvez pas; il n'y a pas de syntaxe pour mettre à jour 'plus d'une variable mutable' avec une seule affectation. Bien sûr, vous pouvez faire
let newX, newY = Swap(x,y)
x <- newX
y <- newY
J'espérais une réponse plus favorable, mais au moins c'est une bonne réponse. Soupir, les incohérences de F # deviennent rapidement une douleur dans mon côté. Je me rends compte que je pousse contre les limites, mais je ne devrais pas les frapper aussi vite. –
Je ne suis pas sûr que je qualifierais de "limite" l'idée que les constructions de langage déconseillées ont une syntaxe moins pratique que les constructions préférées. Rendre les meilleures pratiques aussi les plus pratiques me semble être une bonne idée. –
@Joel. N'est-ce pas la définition de frontière? Si j'utilisais la syntaxe préférée, je n'aurais pas utilisé ce terme. –
Le code que vous avez commenté ne fonctionne pas parce que quand vous écrivez « x, y » vous créez un nouveau tuple qui est une valeur immuable, ne peut donc pas être mis à jour. Vous pouvez créer un tuple mutable puis le remplacer par le résultat de la fonction d'échange si vous voulez:
let mutable toto = 5, 10
let swap (x, y) = y, x
toto <- swap toto
Mon conseil serait d'étudier le côté immuable de F #, regardez les façons dont vous pouvez utiliser des structures immuables réaliser ce que vous auriez fait auparavant en utilisant des valeurs mutables.
Rob
C'est ce qui est probablement voulu –
Si vous voulez généraliser cela, vous devez toujours décompresser le tuple mutable aux valeurs d'origine. Donc vraiment utiliser un tuple mutable est un gâchis. –
Il n'est pas clair pour moi pourquoi vous devez déballer ou même remplacer les nouveaux x et y dans la variable d'origine. Si vous avez un exemple réel, vous devez simplement écrire "let x ', y' = swap x y" et utiliser directement x et y premier. – Robert
Pour développer la réponse 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
rend à la fois les variables et tuple mutable.
Ne fonctionne pas. Lorsque vous imprimez x et y, vous verrez qu'ils n'ont pas changé. Faire xy mutable était juste un rouge-hareng, puisque vous pourriez avoir tout aussi facilement passé dans les variables d'origine. –
Correct, les x et y ne sont pas mis à jour. –
F # a « par référence » paramètres, tout comme C#, de sorte que vous pouvez écrire une fonction d'échange classique similaire:
let swap (x: byref<'a>) (y: byref<'a>) =
let temp = x
x <- y
y <- temp
let mutable x,y = 1,2
swap &x &y
J'apprends python et imaginer comment # frais F pourrait être si nous permettons: 'a, b <- b, a', 'x. [a], x. [b] <- x [b], x [a]' De sorte que 'swap' n'est plus nécessaire. – colinfang