F#: let mutable vs. ref

by

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!

More Related Contents:

  1. F# : not sure how to start [closed]
  2. Understanding F# Value Restriction Errors
  3. How to have two methods calling each other?
  4. Handy F# snippets [closed]
  5. How to constrain one type parameter by another
  6. F# Functions vs. Values
  7. F# Tail Recursive Function Example
  8. Shadowing and Nested function
  9. Use of `inline` in F#
  10. How to Async.AwaitTask on plain Task (not Task)?
  11. How can i convert between F# List and F# Tuple?
  12. Why are functions in OCaml/F# not recursive by default?
  13. Why isn’t there a protected access modifier in F#?
  14. Using keywords as identifiers in F#
  15. Global operator overloading in F#
  16. How to write a function for generic numbers?
  17. Correct version of Fsharp.Core
  18. F# getting a list of random numbers
  19. Why is F#’s type inference so fickle?
  20. While or Tail Recursion in F#, what to use when?
  21. Help me to explain the F# Matrix transpose function
  22. F# Split list into sublists based on comparison of adjacent elements
  23. F# changes to OCaml [closed]
  24. F# interface inheritance failure due to unit
  25. Why are mutable structs “evil”?
  26. Mutable vs immutable objects
  27. How to create a sequence of integers in C#?
  28. Very large collection in .Net causes out-of-memory exception
  29. Why the “mutable default argument fix” syntax is so ugly, asks python newbie
  30. Why are integers immutable in Python?

Leave a Comment