Est-ce que F # parcourt les tuples d'avant en arrière?

Question

J'ai créé un petit tuple de langages et lorsque vous l'utilisez dans la fenêtre interactive, ils sont listés à l'envers. Est-ce normal F # bahavior?

let languages = ("English", "Spanish", "Italian") 
let x, y, z = languages 

val languages : string * string * string = ("English", "Spanish", "Italian") 
val z : string = "Italian" 
val y : string = "Spanish" 
val x : string = "English" 

Answer 1

C'est aussi la manière dont FSI imprime les tuples lorsque je les décompose sur ma machine.

par exemple:

let x, y = ("a", "b") ;;

val y : string = "b" 
val x : string = "a" 

Il est un peu bizarre qu'il imprime en « inverse », mais je ne suis pas sûr que je l'appelle F # comportement autant qu'il est un comportement ou plutôt le comportement FSI d'impression.

Si vous êtes voulez tous les détails, vous pouvez toujours jeter un oeil au code source:

http://fsharppowerpack.codeplex.com/

Answer 2

Vous créez trois variables, en même temps, avec des valeurs indépendantes. L'ordre n'est pas pertinent ici. F # interactive peut imprimer les valeurs dans n'importe quel ordre. Ce qui est important, c'est l'évaluation des commandes dans votre code, et le spec dit que c'est de gauche à droite lorsque vous appelez une fonction ou un constructeur, en créant un enregistrement, et ainsi de suite.

> (printfn "a", printfn "b");; 
a 
b 

Answer 3

Je ne sais pas s'il y a une connexion, mais emballage F expressions # dans Citations peux vous donner un aperçu de la sémantique de la langue, et vous pouvez voir dans ce qui suit que les valeurs nommées sont en effet liés à l'ordre inverse comme indiqué dans FSI:

> <@ let languages = ("English", "Spanish", "Italian") in let x, y, z = languages in() @> |> string;; 
val it : string = 
    "Let (languages, 
    NewTuple (Value ("English"), Value ("Spanish"), Value ("Italian")), 
    Let (z, TupleGet (languages, 2), 
      Let (y, TupleGet (languages, 1), 
       Let (x, TupleGet (languages, 0), Value (<null>)))))" 

Notez que cela reste compatible avec @ réponse de Laurent, qui affirme que les expressions d'argument dans la construction de tuple sont évalués de gauche à droite. Dans l'exemple suivant, voir comment le résultat de la construction du tuple est lié à une valeur nommée intermédiaire, qui est ensuite déconstruite en utilisant des expressions TupleGet sans effets secondaires.

> <@ let x,y = (stdin.Read(), stdin.ReadLine()) in() @> |> string;; 
val it : string = 
    "Let (patternInput, 
    NewTuple (Call (Some (Call (None, System.IO.TextReader ConsoleIn[Object](), 
           [])), Int32 Read(), []), 
       Call (Some (Call (None, System.IO.TextReader ConsoleIn[Object](), 
           [])), System.String ReadLine(), [])), 
    Let (y, TupleGet (patternInput, 1), 
      Let (x, TupleGet (patternInput, 0), Value (<null>))))"