Difference between a Seq and a List in Scala
collections, list, scala, seq
Solution
In Java terms, Scala's `Seq` would be Java's `List`, and Scala's `List` would be Java's `LinkedList`.
Note that `Seq` is a `trait`, which is similar to Java's `interface`, but with the equivalent of up-and-coming defender methods. Scala's `List` is an abstract class that is extended by `Nil` and `::`, which are the concrete implementations of `List`.
So, where Java's `List` is an `interface`, Scala's `List` is an implementation.
Beyond that, Scala's `List` is immutable, which is not the case of `LinkedList`. In fact, Java has no equivalent to immutable collections (the read only thing only guarantees the new object cannot be changed, but you still can change the old one, and, therefore, the "read only" one).
Scala's `List` is highly optimized by compiler and libraries, and it's a fundamental data type in functional programming. However, it has limitations and it's inadequate for parallel programming. These days, `Vector` is a better choice than `List`, but habit is hard to break.
`Seq` is a good generalization for sequences, so if you program to interfaces, you should use that. Note that there are actually three of them: `collection.Seq`, `collection.mutable.Seq` and `collection.immutable.Seq`, and it is the latter one that is the "default" imported into scope.
There's also `GenSeq` and `ParSeq`. The latter methods run in parallel where possible, while the former is parent to both `Seq` and `ParSeq`, being a suitable generalization for when there is no concern for code parallelism. They are both relatively new, so people don't use them as much.
Problem
I've seen in many examples that sometimes a Seq is being used, while other times is the List... Is there any difference, other than the former one being a Scala type and the List coming from Java?