Back to Questions
1.3k
views10
comments
Stack vs. Heap
f#

Hi.
I have some questions about memory allocation in F#.
So the ref directive in the following code let refCell = ref 42 is somehow equivalent to the C's malloc function, and the new is like C#'s new keyword. Am I right?

.

Hi, the value created using 'ref' is managed too as already said.
Using the C# terminology, 'ref' creates just a very simple (managed heap allocated) object that could look like this in C#:

1
2
3
4
5
6
7
8

 
class Ref<T> { 
  public Ref(T init) { Value = init; }
  public T Value { get; set; } 
}

// let refCell = ref 42 corresponds to:
var refCell = new Ref<int>(42);
By on 3/10/2009 5:23 AM ()

Hi, the value created using 'ref' is managed too as already said.
Using the C# terminology, 'ref' creates just a very simple (managed heap allocated) object that could look like this in C#:

1
2
3
4
5
6
7
8

 
class Ref<T> { 
  public Ref(T init) { Value = init; }
  public T Value { get; set; } 
}

// let refCell = ref 42 corresponds to:
var refCell = new Ref<int>(42);

So 'ref' is just an alternative way to say 'new', in a F# way?

By on 3/10/2009 6:48 AM ()

Hmm.. ref and new are totally different. ref creates a variable that you can modify, new creates a variable, regardless of whether or not you can modify it.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

> let x = ref 5
val x : int ref

> x;;
val it : int ref = {contents = 5;}

> x := 7
val it :  unit = ()

> x;;
val it : int ref = {contents = 7;}


> let x = new int;;
val x : int

> x;;
val it : int = 0

> x := 5;;
Error: This expression has type int but is used here with type 'a ref.

The purpose of new is to create, or allocate memory for things. The purpose of ref is to indicate that something, regardless of how its memory is allocated, can be modified after it is created. So ref really doesn't have anything to do with memory allocation, stacks, or heaps.

In C#, every variable you declare is similar to an F# ref variable (they aren't exactly the same but for simplicity we can just consider them the same). But C# also has a 'const' keyword, which is analogous to not specifying anything on the variable in F#.

1
2
3
4
5

let x = ref 5     (*int x = 5;   //C#*)
let y = 5          (*const int y = 5;    //C#*)
let z = new int()    (*int z = new int();    //C#*)

x := 5    (*x = 5;   //C#*)
By on 3/10/2009 7:16 AM ()

Hmm.. ref and new are totally different. ref creates a variable that you can modify, new creates a variable, regardless of whether or not you can modify it.

One small objection -they're values, not variables. I think talking about variables in this context isn't correct.

ref doesn't create something you can modify. It returns a value of type Ref that has a mutable field, but I don't think that's the same concept as a variable you can modify.

Here's a question for people more experienced with F# - is "a value of type Ref that has a mutable field" the correct phrase, or is there a better way to say it? This seems like one of the places where saying the exact right thing will be very helpful for beginners.

Definitely take a look at the definitions of ref - if you're in Visual Studio, just put the cursor on ref and hit F12. It'll take you to prim-types.fs, where you'll see:

1
2
3
4
5
6
7

    type Ref<'a> = 
        { mutable contents: 'a }
        member x.Value 
            with get() = x.contents
            and  set v = x.contents <- v

    and 'a ref = Ref<'a>
By on 3/10/2009 10:51 AM ()

eh, whatever I wasn't trying to be technical I was just trying to explain it in simple terms, lol.

mutable and ref are almost interchangeable, which you can even see from the definition you posted of ref above. a ref type just an abstraction that's defined in terms of mutable.

Either way, the difference between ref/mutable and new is that one refers to a keyword that is used for allocating types and objects, and one is a type modifier that tells the compiler to allow you to modify the value after it's been created.

By on 3/10/2009 2:47 PM ()

er no - there is a huge difference between mutable and ref and that is the place the memory for the "value" is allocated.

Just try to use a "mutable var" inside a closure and let the compiler explain the point to you ;)

By on 3/10/2009 11:02 PM ()

No, ref is a function that creates new instance of the "Ref" object (that I described in the previous post). Unlike new, which is a keyword, ref is just an ordinary (pre-defined) function. The C# version of the ref function (let's call it CreateRef) would be defined like this in C#:

1
2
3

static Ref<T> CreateRef<T>(T initial) { 
  return new Ref<T>(initial);
}

As you can see, "ref 42" is just a call to a function with some initial value as an argument. The returned value is of type Ref<int> which is just a value wrapped inside an object, so that it can be mutated using (:=) operator.

By on 3/10/2009 7:10 AM ()

No, ref is a function that creates new instance of the "Ref" object (that I described in the previous post). Unlike new, which is a keyword, ref is just an ordinary (pre-defined) function. The C# version of the ref function (let's call it CreateRef) would be defined like this in C#:

1
2
3

static Ref<T> CreateRef<T>(T initial) { 
  return new Ref<T>(initial);
}

As you can see, "ref 42" is just a call to a function with some initial value as an argument. The returned value is of type Ref<int> which is just a value wrapped inside an object, so that it can be mutated using (:=) operator.

I meant the both produce the same effect, but never mind. Yet another question if possible. So by default all F# values, including functions(which are first class objects), are created in the stack. In order to create a value in the heap, one has to call ref func or use new keyword. Am I right? Is it possible to create functions in the heap? I tried it with ref, but didn't succeeded.
ps
And another question: Why there are two different operators for referencing and dereferencing a value created in the heap by the ref?

Thanks

By on 3/11/2009 6:15 AM ()

So by default all F# values, including functions(which are first class objects), are created in the stack. In order to create a value in the heap, one has to call ref func or use new keyword. Am I right? Is it possible to create functions in the heap? I tried it with ref, but didn't succeeded.

No. In F# (and more generally .Net), most everything is created on the heap, except value types (structs and primitives like 'int'). Functions in F#, for example, are typically represented as instances of the F# 'FastFunc' class, and since it is a class, it is always heap-allocated. In a typical program many F# names are references bound to objects on the heap.

You typically use 'ref' when you need to create a shared mutable storage cell, often for what would otherwise be a stack-allocated object (like an int). 'ref 3' creates a new Ref<int> object on the heap, which has a single 'int' field that is mutable. Multiple names can refer to this object and share this mutable state.

You can create a ref to anything, including a function; for example

1
2

let inc x = x + 1
let rf = ref inc
By on 3/11/2009 6:39 AM ()

No the ref - call is managed too and as far as I know it's just a referenced cell on the heap.

By on 3/10/2009 4:57 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper