F # : 让 mutable vs. ref

首先，我承认这个问题有可能是一个复制品; 请让我知道。

我很好奇在需要可变性的情况下，一般的“最佳实践”是什么。F # 似乎为此提供了两种工具: let mutable绑定，在“大多数”语言中，它似乎像变量一样工作; 以及引用单元(用 ref函数创建) ，它需要显式的解引用才能使用。

有几种情况，其中一个是“强迫”到一个或另一个: 。NET 互操作倾向于在 <-中使用可变的，并且在工作流计算中必须在 :=中使用 ref。所以这些情况非常明确，但我很好奇在这些情况之外创建自己的可变变量时要做些什么。一种风格比另一种风格有什么优势？(或许进一步深入了解实现会有所帮助。)

谢谢！

18149 次浏览
小开

Related Question: "You mentioned that local mutable values cannot be captured by a closure, so you need to use ref instead. The reason for this is that mutable values captured in the closure need to be allocated on the heap (because closure is allocated on the heap)." from F# ref-mutable vars vs object fields

I think let mutable is preferred over reference cells. I personally only use reference cells when they are required.

Most code I write doesn't use mutable variables thanks to recursion and tail calls. If I have a group of mutable data I use a record. For objects I use let mutable to make private mutable variables. I only really use reference cells for closures, generally events.

小开

You may want to take a look at the Mutable Data section in the wikibook.

For convenience, here are some relevant quotes:

The mutable keyword is frequently used with record types to create mutable records

Mutable variables are somewhat limited: mutables are inaccessible outside of the scope of the function where they are defined. Specifically, this means its not possible to reference a mutable in a subfunction of another function.

Ref cells get around some of the limitations of mutables. In fact, ref cells are very simple data type which wrap up a mutable field in a record type.

Since ref cells are allocated on the heap, they can be shared across multiple functions

小开
最佳答案

I can only support what gradbot said - when I need mutation, I prefer let mutable.

Regarding the implementation and differences between the two - ref cells are essentially implemented by a very simple record that contains a mutable record field. You could write them easily yourself:

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 }

A notable difference between the two approaches is that let mutable stores the mutable value on the stack (as a mutable variable in C#) while ref stores the mutable value in a field of a heap-allocated record. This may have some impact on the performance, but I don't have any numbers...

Thanks to this, mutable values that use ref can be aliased - meaning that you can create two values that reference the same mutable value:

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!
小开

This article by Brian might provide an answer.

Mutables are easy to use and efficient (no wrapping), but can't be captured in lambdas. Ref cells can be captured, but are verbose and less efficient (? - not sure of this).

小开

As described in this MSDN Blog article in section Simplified use of mutable values, you no longer need ref cells for lambdas. So in general you no longer need them at all.


提交答案