F#: laissez mutable vs ref

Tout d'abord, je reconnais la possibilité que cette question pourrait être un doublon; laissez-moi savoir.

Je suis curieux de ce que le général "meilleures pratiques" pour les situations où la mutabilité est souhaitée. F# semble offrir deux possibilités pour cela: le let mutable de liaison, qui semble fonctionner comme des variables dans "la plupart" des langues, et la cellule de référence (créé avec l' ref fonction) qui nécessite une référence explicite à utiliser.

Il y a quelques cas où l'on est "forcé" dans l'un ou de l'autre: .NET interop a tendance à utiliser des mutable avec <-, et dans les calculs de flux de travail, on doit utiliser ref avec :=. Si ces cas sont assez claires, mais je suis curieux de savoir quoi faire lors de la création de mon propre mutable variables en dehors de ces scénarios. Quels sont les avantages d'un style de ont sur les autres? (Peut-être un aperçu plus loin dans la mise en œuvre de l'aide.)

Merci!

InformationsquelleAutor J Cooper | 2010-07-10
  1. 124

    Je ne peux qu'appuyer ce que gradbot dit - quand j'ai besoin de mutation, je préfère let mutable.

    Concernant la mise en œuvre et les différences entre les deux ref les cellules sont mises en œuvre essentiellement par une très simple enregistrement qui contient une mutable enregistrement de domaine. Vous pouvez les écrire facilement vous-même:

    type ref<'T> =  //'
  { mutable value : 'T } //'

//the ref function, ! and := operators look like this:
let (!) (a:ref<_>) = a.value
let (:=) (a:ref<_>) v = a.value <- v
let ref v = { value = v }

    Une différence notable entre les deux approches est que let mutable magasins de la mutable valeur sur la pile (comme une variable mutable en C#), tandis que ref magasins de la mutable valeur dans un champ d'un segment de mémoire allouée dossier. Cela peut avoir une incidence sur les performances, mais je n'ai pas tous les numéros...

    Grâce à cela, les valeurs mutables qui utilisent ref peut être un alias - ce qui signifie que vous pouvez créer deux valeurs font référence à la même mutable valeur:

    let a = ref 5  //allocates a new record on the heap
let b = a      //b references the same record
b := 10        //modifies the value of 'a' as well!

let mutable a = 5 //mutable value on the stack
let mutable b = a //new mutable value initialized to current value of 'a'
b <- 10           //modifies the value of 'b' only!
    • +1, bel exemple de code.
    • Juste un rappel: les cours sur la pile ou le tas est un détail d'implémentation, et n'ont pas pertinente à la question (mais excellente réponse néanmoins)
    • Je dirais que le fait de savoir si quelque chose entraîne la surcharge des tas de répartition et de recouvrement ou pas, c'est extrêmement pertinent au moment de décider sur ce que les meilleures pratiques.
    • découvrez cet article par Eric Lippert appelé La Pile Est Un Détail d'Implémentation
    • oui je comprends que fondamentalement je suis en complet désaccord avec eric sur ce point. Vous ne pouvez pas quitter la performance au-delà des considérations lorsque l'on considère ce qu'est une "meilleure pratique". Il est souvent affirmé que la performance n'a pas d'importance mais beaucoup de logiciel est lent en raison de la mort d'un millier de détails de mise en œuvre.
    InformationsquelleAutor Tomas Petricek
  2. 18

    Liés à la Question: "Vous avez mentionné que les collectivités locales de valeurs mutables ne peut pas être capturé par une fermeture, alors vous devez utiliser la ref à la place. La raison pour cela est que les valeurs mutables capturé dans la fermeture doivent être alloués sur le tas (en raison de la fermeture est alloué sur le tas)." de F# ref-mutable vars vs champs d'objet

    Je pense que let mutable est préféré plus de cellules de référence. Personnellement, je utiliser uniquement les cellules de référence lorsqu'ils sont requis.

    Plus code que j'ai écris ne pas utiliser des variables mutables grâce à la récursivité et la queue des appels. Si j'ai un groupe de données mutable-je utiliser un record. Pour les objets que j'utilise let mutable rendre privé mutable variables. Je n'ai vraiment utiliser les cellules de référence pour les fermetures, généralement des événements.

    InformationsquelleAutor gradbot
  3. 7

    Comme décrit dans cet article du Blog MSDN dans la section Simplifié l'utilisation de valeurs mutables, vous n'avez plus besoin réf cellules pour les lambdas.
    Donc, en général, vous n'avez plus besoin d'eux à tous.

    InformationsquelleAutor Andrii
  4. 4

    Cet article par Brian pourrait fournir une réponse.

    Des mutables sont faciles à utiliser et efficace (sans emballage), mais ne peuvent pas être capturés dans les lambdas. Ref cellules peut être capturé, mais sont prolixes et de moins en moins efficace (? - pas sûr de cette partie).

    • "(...) et de moins en moins efficace" - probablement, une enveloppe de type prend plus de mémoire.
    • Ce qui a changé, depuis F# 4.0 mutable peut être capturé dans la plupart des cas et le besoin de ref est maintenant beaucoup moins.
    InformationsquelleAutor Mau
  5. 3

    Vous pouvez prendre un coup d'oeil à la Données Mutable section dans le wikibook.

    Pour des raisons de commodité, voici quelques citations:

    Le mot-clé mutable est fréquemment utilisé
    avec les types d'enregistrements pour créer mutable
    enregistrements

    Mutable variables sont un peu
    limité: des mutables sont inaccessibles
    en dehors de la portée de la fonction
    où elles sont définies. Plus précisément,
    cela signifie que ce n'est pas possible de
    référence à un mutables dans une sous-fonction
    d'une autre fonction.

    Ref cellules obtenir autour de certains
    limitations de des mutables. En fait, réf.
    les cellules sont très simples type de données qui
    envelopper mutable champ dans un enregistrement
    type.

    Depuis réf cellules sont affectées sur la
    tas, ils peuvent être partagées à travers
    de multiples fonctions

    InformationsquelleAutor danlei