Question

I’m a C# developer new to F#,I understand that in .net the strings are immutable. In other words every time you modify a string you get a new string instance.

For a non functional mind like mine the first question would be efficiency and I understand that C# mutable objects are not persistent. since string manipulation is normally trivial in most of applications.

My question is, Is this the case for F# lists too?, Do F# clones every list on change? Like for example, when filtering a list do I create a new list with fewer Items?

Update: I’m not comparing .net string and lists. I named string as an example of an immutable object and want to know if F# provides any special treatment for it’s List.

This is what I mean by “persistent“.

Answer 1

I think Dustin Campbell’s introduction does an amazing job of explaining list immutability.

In the functional world, lists are immutable. This means that node sharing is possible because the original lists will never change. Because the first list ends with the empty list, its nodes must be copied in order to point its last node to the second list. After the append operation, our lists look like so:

At this point, the more skeptical among you might be saying, “Well,
that’s a pretty interesting theory, but can you prove it?”

No problem.

Using the knowledge that F# lists are recursive, we can retrieve the
last half of combined (the inner list starting at 4) by taking the
tail, of its tail, of its tail. List.tl is the function that F#
provides for extracting a list’s tail.

> let lastHalf = List.tl (List.tl (List.tl combined));;

val lastHalf : int list

> lastHalf;;

val it : int list = [4; 5; 6]

Finally, because F# is first-class citizen of the .NET Framework, we
have full access to all of the base class libraries. So, we can use
the Object.ReferenceEquals method to test whether or not lastHalf
and second are indeed the same instance.

> System.Object.ReferenceEquals(lastHalf, second);;

val it : bool = true

And there you have it. Believe it or not, appending two immutable
lists can actually be faster and more memory efficient than appending
mutable lists because fewer nodes have to be copied.