Reputation: 13063
I understand that a list actually contains values, and a sequence is an alias for IEnumerable<T>
. In practical F# development, when should I be using a sequence as opposed to a list?
Here's some reasons I can see when a sequence would be better:
IEnumerable<T>
. Are there any others?
Upvotes: 94
Views: 15236
Reputation: 5002
list is more functional, math-friendly. when each element is equal, 2 lists are equal.
sequence is not.
let list1 = [1..3]
let list2 = [1..3]
printfn "equal lists? %b" (list1=list2)
let seq1 = seq {1..3}
let seq2 = seq {1..3}
printfn "equal seqs? %b" (seq1=seq2)
Upvotes: 8
Reputation: 5187
You should always expose Seq
in your public APIs. Use List
and Array
in your internal implementations.
Upvotes: 6
Reputation: 48717
Also prefer seq
when:
You don't want to hold all elements in memory at the same time.
Performance is not important.
You need to do something before and after enumeration, e.g. connect to a database and close connection.
You are not concatenating (repeated Seq.append
will stack overflow).
Prefer list
when:
There are few elements.
You'll be prepending and decapitating a lot.
Neither seq
nor list
are good for parallelism but that does not necessarily mean they are bad either. For example, you could use either to represent a small bunch of separate work items to be done in parallel.
Upvotes: 32
Reputation: 243096
I think your summary for when to choose Seq
is pretty good. Here are some additional points:
Seq
by default when writing functions, because then they work with any .NET collectionSeq
if you need advanced functions like Seq.windowed
or Seq.pairwise
I think choosing Seq
by default is the best option, so when would I choose different type?
Use List
when you need recursive processing using the head::tail
patterns
(to implement some functionality that's not available in standard library)
Use List
when you need a simple immutable data structure that you can build step-by-step
(for example, if you need to process the list on one thread - to show some statistics - and concurrently continue building the list on another thread as you receive more values i.e. from a network service)
Use List
when you work with short lists - list is the best data structure to use if the value often represents an empty list, because it is very efficient in that scenario
Use Array
when you need large collections of value types
(arrays store data in a flat memory block, so they are more memory efficient in this case)
Use Array
when you need random access or more performance (and cache locality)
Upvotes: 111
Reputation: 41290
Just one small point: Seq
and Array
are better than List
for parallelism.
You have several options: PSeq from F# PowerPack, Array.Parallel module and Async.Parallel (asynchronous computation). List is awful for parallel execution due to its sequential nature (head::tail
composition).
Upvotes: 13