Should I use List[A] or Seq[A] or something else?
design-patterns, scala
Solution
I think, in general, you should use `Seq` for your parameters and design your methods to work efficiently with `List`. This way your methods will work ok with most `Seq` implementations and you will not have to convert your seqs prior to use your methods.
Edit
Your question has many questions inside.
- So which general purpose stack-like data-structure shall I write my methods and algorithms for?
- I think the answer here is `List`. It's a stack and it's very fast
- Can I choose a type that will force efficiency on those operations?
- In general you'll have to rely on a concerete implementation. The performance characteristics are here http://www.scala-lang.org/docu/files/collections-api/collections_40.html
- For example shall I use TraversableOnce or IndexedSeq instead of List or Array? Will it buy me anything?
- Some abstractions have performance characteristics defined, some others don't. For example `IndexedSeq` scaladoc says "Indexed sequences support constant-time or near constant-time element access and length computation". If you have an `IndexedSeq` parameter and someone passes an `IndexedSeq` implementation that does not have "near-constant time element access", then that someone is breaking the contract and it's not your problem.
- What is your default List-like data-structure signature?
- Seq
Problem
I was writing a class that contained some functional-esque methods. First I wrote them using List as parameters and return types. Then I thought "Hey, you could also use a more generic type!" so I replaced the Lists with Seq, hoping that I could make my stuff faster one day by feeding them something else than lists. So which general purpose stack-like data-structure shall I write my methods and algorithms for? Is there a general pattern I can stick to? All this is because the methods might need to get optimized in the future in case they will form a bottle-neck. Update I'll try to be a bit more precise: Given you know which operations you are using, like reversing, .tail, direct element access, or for comprehensions. Can I choose a type that will force efficiency on those operations? Update 2 I'm quite aware of the performance of concrete data structures for various tasks. What I'm not aware of is which data structure might appear as a sub-class of some super type. For example shall I use TraversableOnce or IndexedSeq instead of List or Array? Will it buy me anything? Additional Question What is your default List-like data-structure signature? Do you write ``` def a(b: List[A]): List[A] ``` or ``` def a(b: TraversableOnce[A]): TraversableOnce[A] ``` Can you explain why?