What is the difference between lists, arrays and tuples in F #?

Question

What is the difference between lists, arrays and tuples in F #? Is it easy to convert between them when necessary? They seem similar in spirit, so I really need to know what allows me to understand when to use one against the other?

Answer 1

A tuple is a grouping of unnamed, ordered values. Each value in a tuple does not have to be of the same type, which means that you can have a tuple defined as:

let someTuple = (1, "foo", 42.3) 

This will create a tuple containing the value of int, string and float.

A list is an ordered set of values ​​of the same type that is immutable. This is probably the most common type of collection used in functional programming, since it is completely unchanged and has many functions for creating lists created on top of previously created lists, which allows you to create collections that "grow" (they are actually new collections, however, as lists are immutable).

An array is a modified collection. They are very effective for creation, but must always be of the same type.

Is it easy to convert between them if necessary?

It is very easy to convert between lists and arrays. You can use List.ofArray , List.toArray , Array.ofList and Array.toList to convert between types.

Converting from a tuple to an array or list is not common, and not always possible, because tuples allow you to store several types in it.

They seem similar in spirit, so I really need to know what allows me to understand when to use one against the other?

Lists and arrays are used for collections. In general, you will want to give preference to lists if you intend to create lists that "grow", since creating a new list consisting of the + element, the original list is much more efficient than the same with the array.

Arrays are often used for better performance scenarios (they have better memory locality, more economical places, etc.), but they are mutable and fixed, so they are often not ideal when you try to work with building collections.

Tuples are commonly used for completely different scenarios. The most common use case for tuples is to pass in multiple elements as a single value. This happens automatically when using infrastructure methods that have out parameters, for example, so you will see usage examples, such as:

 let (success, value) = int.TryParse(someString) 

In this case, a tuple is automatically created, and then the template is matched to retrieve the values ​​in a single line of code. Instead of thinking of a tuple as a “collection”, it is rather a way to hold several values, often of different types, together.

Answer 2

About using collection types:

Lists when : you need a dynamic collection that changes in size. A list is a unidirectional linked list, so keep in mind that for each member of the list, 4 or 8 bytes of additional memory are required, storing a pointer to the next list item.

Arrays when : you need to store a large number of primitive values, such as int, float or bytes. Arrays are a static block of memory reserved for values, this is effective when you need to store, for example, image bytes.

Additional useful collections:

Sets when : you need to save, well, the set. A set is a set of unique values. The set has useful functions for calculating the difference, union, and intersection. For example, you can have many people (A) and many people who bought sweets (B) so that you can now calculate AB = C, now you have set C, which represents people who did not buy sweets.

Cards when : you need a projection from one value to another. Now in the previous example, you calculated set C (people who didn’t buy candy), you probably used some identifier to describe these people. Now you can project this identifier onto a person’s record using Map :).

Hope this was helpful.