There&#39;s something I don&#39;t understand about Scala&#39;s [`collection.mutable.Seq`](http://www.scala-lang.org/api/current/index.html#scala.collection.mutable.Seq). It describes the interface for all mutable sequences, yet I don&#39;t see methods to append or prepend elements without creating a new sequence. Am I missing something obvious here?

There are `:+` and `+:` for append and prepend, respectively, but they create new collections — in order to be consistent with the behavior of immutable sequences, I assume. This is fine, but why is there no method like `+=` and `+=:`, like `ArrayBuffer` and `ListBuffer` define, for in-place append and prepend? Does it mean that I cannot refer to a mutable seq that&#39;s typed as `collection.mutable.Seq` if I want to do in-place append?

Again, I must have missed something obvious, but cannot find what…

How to append or prepend on a Scala mutable.Seq

In Scala, for many (all?) types of collections you can create views.

What exactly is a view and for which purposes are views useful?

What are views for collections and when would you want to use them?

given:

    val m = Map[String, Int](&quot;a&quot; -&gt; 1, &quot;b&quot; -&gt; 2, &quot;c&quot; -&gt; 3)
    m.foreach((key: String, value: Int) =&gt; println(&quot;&gt;&gt;&gt; key=&quot; + key + &quot;, value=&quot; + value))

why does the compiler complain 

    error: type mismatch
    found   : (String, Int) =&gt; Unit
    required: (String, Int) =&gt; ?




Scala Map foreach

In Scala there is a Stream class that is very much like an iterator.  The topic [Difference between Iterator and Stream in Scala?](https://stackoverflow.com/questions/1527962/difference-between-iterator-and-stream-in-scala) offers some insights into the similarities and differences between the two.

Seeing how to use a stream is pretty simple but I don&#39;t have very many **common** use-cases where I would use a stream instead of other artifacts.  
 

The ideas I have right now:

 - If you need to make use of an infinite series.  But this does not seem like a common use-case to me so it doesn&#39;t fit my criteria.  (Please correct me if it is common and I just have a blind spot)
 - If you have a series of data where each element needs to be computed but that you may want to reuse several times.  This is weak because I could just load it into a list which is conceptually easier to follow for a large subset of the developer population.  
 - Perhaps there is a large set of data or a computationally expensive series and there is a high probability that the items you need will not require visiting all of the elements.  But in this case an Iterator would be a good match unless you need to do several searches, in that case you could use a list as well even if it would be slightly less efficient.
 - There is a complex series of data that needs to be reused.  Again a list could be used here.  Although in this case both cases would be equally difficult to use and a Stream would be a better fit since not all elements need to be loaded.  But again not that common... or is it?

So have I missed any big uses?  Or is it a developer preference for the most part?

Thanks

Use-cases for Streams in Scala

In Scala **2.8**, there is an object in `scala.collection.package.scala`:

    def breakOut[From, T, To](implicit b : CanBuildFrom[Nothing, T, To]) =
        new CanBuildFrom[From, T, To] {
            def apply(from: From) = b.apply() ; def apply() = b.apply()
     }

I have been told that this results in:

    &gt; import scala.collection.breakOut
    &gt; val map : Map[Int,String] = List(&quot;London&quot;, &quot;Paris&quot;).map(x =&gt; (x.length, x))(breakOut)

    map: Map[Int,String] = Map(6 -&gt; London, 5 -&gt; Paris)

What is going on here? Why is `breakOut` being called *as an argument* to my `List`?


Scala 2.8 breakOut

It seems that `Vector` was late to the Scala collections party, and all the influential blog posts had already left.

In Java `ArrayList` is the default collection - I might use `LinkedList` but only when I&#39;ve thought through an algorithm and care enough to optimise. In Scala should I be using `Vector` as my default `Seq`, or trying to work out when `List` is actually more appropriate?

When should I choose Vector in Scala?

In [`scala.collection`](http://www.scala-lang.org/api/current/index.html#scala.collection.package), there are two very similar objects [`JavaConversions`](http://www.scala-lang.org/api/current/scala/collection/JavaConversions$.html) and [`JavaConverters`](http://www.scala-lang.org/api/current/scala/collection/JavaConverters$.html). 

* What is the difference between these two objects? 
* Why do they both exist?
* When do I want to use one vs. the other?

What is the difference between JavaConverters and JavaConversions in Scala?

When should I use `reduceLeft`, `reduceRight`, `foldLeft`, `foldRight`, `scanLeft` or `scanRight`?

I want an intuition/overview of their differences - possibly with some simple examples.

Reduce, fold or scan (Left/Right)?

I have just started to look at the [Scala collections library re-implementation][1] which is coming in the imminent **2.8** release. Those familiar with the library from 2.7 will notice that the library, from a usage perspective, has changed little. For example...

    &gt; List(&quot;Paris&quot;, &quot;London&quot;).map(_.length)
    res0: List[Int] List(5, 6)

...would work in either versions. **The library is eminently useable**: in fact it&#39;s fantastic. However, those previously unfamiliar with Scala and *poking around to get a feel for the language* now have to make sense of method signatures like:

    def map[B, That](f: A =&gt; B)(implicit bf: CanBuildFrom[Repr, B, That]): That

For such simple functionality, this is a daunting signature and one which I find myself struggling to understand. **Not that I think Scala was ever likely to be the next Java** (or /C/C++/C#) - I don&#39;t believe its creators were aiming it at that market - but I think it is/was certainly feasible for Scala to become the next Ruby or Python (i.e. to gain a significant commercial user-base)

 - Is this going to put people off coming to Scala?
 - Is this going to give Scala a bad name in the commercial world as an *academic plaything* that only dedicated PhD students can understand? Are [CTO][2]s and heads of software going to get scared off?
 - Was the library re-design a sensible idea?
 - If you&#39;re using Scala commercially, are you worried about this? Are you planning to adopt 2.8 immediately or wait to see what happens?


[Steve Yegge][3] [once attacked Scala][4] (mistakenly in my opinion) for what he saw as its overcomplicated type-system. I worry that someone is going to have a field day spreading [FUD][5] with this API (similarly to how Josh Bloch scared the [JCP][6] out of adding closures to Java).

**Note** - *I should be clear that, whilst I believe that [Joshua Bloch][7] was influential in the rejection of the BGGA closures proposal, I don&#39;t ascribe this to anything other than his honestly-held beliefs that the proposal represented a mistake.*

&lt;hr/&gt;

Despite whatever my wife and coworkers keep telling me, I don&#39;t think I&#39;m an idiot: I have a good degree in mathematics from the [University of Oxford][8], and I&#39;ve been programming commercially for almost 12 years and in [Scala][9] for about a year (also commercially).

*Note the inflammatory subject title is a [quotation made about the manifesto of a UK political party][10] in the early 1980s*. This question is subjective but it is a genuine question, I&#39;ve made it CW and I&#39;d like some opinions on the matter.

  [1]: http://lampsvn.epfl.ch/trac/scala/browser/scala/trunk/src/library/scala/collection
  [2]: http://en.wikipedia.org/wiki/Chief_technical_officer
  [3]: http://en.wikipedia.org/wiki/Steve_Yegge
  [4]: http://steve-yegge.blogspot.com/2008/06/rhinos-and-tigers.html
  [5]: http://en.wikipedia.org/wiki/Fear,_uncertainty_and_doubt
  [6]: http://en.wikipedia.org/wiki/Java_Community_Process
  [7]: https://en.wikipedia.org/wiki/Joshua_Bloch
  [8]: http://www.ox.ac.uk/
  [9]: http://en.wikipedia.org/wiki/Scala_%28programming_language%29
  [10]: http://en.wikipedia.org/wiki/The_longest_suicide_note_in_history


Is the Scala 2.8 collections library a case of &quot;the longest suicide note in history&quot;?

If I have a collection `c` of type `T` and there is a property `p` on `T` (of type `P`, say), what is the best way to do a *map-by-extracting-key*?

    val c: Collection[T]
    val m: Map[P, T]

One way is the following:

    m = new HashMap[P, T]
    c foreach { t =&gt; m add (t.getP, t) }

But now I need a *mutable* map. Is there a better way of doing this so that it&#39;s in 1 line and I end up with an *immutable* Map? (Obviously I could turn the above into a simple library utility, as I would in Java, but I suspect that in Scala there is no need)

Scala best way of turning a Collection into a Map-by-key?

In what cases I should use Array(Buffer) and List(Buffer). Only one difference that I know is that arrays are nonvariant and lists are covariant. But what about performance and some other characteristics? 

Difference between Array and List in scala

What are the differences among Streams, Views (SeqView), and Iterators in scala? This is my understanding:

* They are all lazy lists.
* Streams cache the values.
* Iterators can only be used once? You can&#39;t go back to the beginning and evaluate the value again?
* View&#39;s values are not cached but you can evaluate them again and again?

So if I want to save heap space, should I use iterators (if I won&#39;t traverse the list again) or views? Thanks. 

Stream vs Views vs Iterators

I have a folder structure like below:

    - main
    -- java
    -- resources 
    -- scalaresources
    --- commandFiles 

and in that folders I have my files that I have to read.
Here is the code:


            

    def readData(runtype: String, snmphost: String, comstring: String, specificType:  String): Unit = {
      val realOrInvFile = &quot;/commandFiles/snmpcmds.&quot; +runtype.trim // these files are under commandFiles folder, which I have to read. 
        try {
          if (specificType.equalsIgnoreCase(&quot;Cisco&quot;)) {
            val specificDeviceFile: String = &quot;/commandFiles/snmpcmds.&quot;+runtype.trim+ &quot;.cisco&quot;
            val realOrInvCmdsList = scala.io.Source.fromFile(realOrInvFile).getLines().toList.filterNot(line =&gt; line.startsWith(&quot;#&quot;)).map{
              //some code 
            }
            val specificCmdsList = scala.io.Source.fromFile(specificDeviceFile).getLines().toList.filterNot(line =&gt; line.startsWith(&quot;#&quot;)).map{
              //some code
            }
          }
        } catch {
          case e: Exception =&gt; e.printStackTrace
        }
      }
    }
         
         

   

How to read files from resources folder in Scala?

Being new to Scala (2.9.1), I have a `List[Event]` and would like to copy it into a `Queue[Event]`, but the following Syntax yields a `Queue[List[Event]]` instead:

    val eventQueue = Queue(events)

For some reason, the following works:

    val eventQueue = Queue(events : _*)

But I would like to understand what it does, and why it works? I already looked at the signature of the `Queue.apply` function:

    def apply[A](elems: A*)

And I understand why the first attempt doesn&#39;t work, but what&#39;s the meaning of the second one? What is `:`, and `_*` in this case, and why doesn&#39;t the `apply` function just take an `Iterable[A]` ?


What does param: _* mean in Scala?

I have looked at [this question][1] but still don&#39;t understand the difference between Iterable and Traversable traits. Can someone explain ?


  [1]: https://stackoverflow.com/questions/2602379/in-scala-2-8-collections-why-was-the-traversable-type-added-above-iterable

Scala: What is the difference between Traversable and Iterable traits in Scala collections?

I am trying to get a subarray in scala, and I am a little confused on what the proper way of doing it is.  What I would like the most would be something like how you can do it in python:

    x = [3, 2, 1]
    x[0:2]

but I am fairly certain you cannot do this.

The most obvious way to do it would be to use the Java Arrays util library.

    import java.util.Arrays
    val start = Array(1, 2, 3)
    Arrays.copyOfRange(start, 0, 2)

But it always makes me feel a little dirty to use Java libraries in Scala.  The most &quot;scalaic&quot; way I found to do it would be

    def main(args: List[String]) {
        val start = Array(1, 2, 3)
        arrayCopy(start, 0, 2)
    }
    def arrayCopy[A](arr: Array[A], start: Int, end: Int)(implicit manifest: Manifest[A]): Array[A] = {
        val ret = new Array(end - start)
        Array.copy(arr, start, ret, 0, end - start)
        ret
    }

but is there a better way?

What is the correct way to get a subarray in Scala?

Learning Scala currently and needed to invert a Map to do some inverted value-&gt;key lookups.  I was looking for a simple way to do this, but came up with only:

    (Map() ++ origMap.map(kvp=&gt;(kvp._2-&gt;kvp._1)))

Anybody have a more elegant approach?

Elegant way to invert a map in Scala

**EDIT**: Re-written this question based on original answer

The `scala.collection.immutable.Set` class is not covariant in its type parameter. Why is this? 

    import scala.collection.immutable._

    def foo(s: Set[CharSequence]): Unit = {
        println(s)
    }

    def bar(): Unit = {
       val s: Set[String] = Set(&quot;Hello&quot;, &quot;World&quot;);
       foo(s); //DOES NOT COMPILE, regardless of whether type is declared 
               //explicitly in the val s declaration
    }



Why is Scala&#39;s immutable Set not covariant in its type?

Related to Stack Overflow question *[Scala equivalent of new HashSet(Collection) ][1]*, how do I convert a Java collection (`java.util.List` say) into a Scala collection `List`?

I am actually trying to convert a Java API call to [Spring&#39;s][2] `SimpleJdbcTemplate`, which returns a `java.util.List&lt;T&gt;`, into a Scala immutable `HashSet`. So for example:

    val l: java.util.List[String] = javaApi.query( ... )
    val s: HashSet[String] = //make a set from l

----------

This seems to work. Criticism is welcome!
    
    import scala.collection.immutable.Set
    import scala.collection.jcl.Buffer 
    val s: scala.collection.Set[String] =
                          Set(Buffer(javaApi.query( ... ) ) : _ *)

  [1]: https://stackoverflow.com/questions/674545
  [2]: http://en.wikipedia.org/wiki/Spring_Framework


Converting a Java collection into a Scala collection

Is it always more performant to use withFilter instead of filter, when afterwards applying       functions like map, flatmap etc.?

Why are only map, flatmap and foreach supported? (Expected functions like forall/exists as well)  

withFilter instead of filter

    private[this]object MMMap extends  HashMap[A, Set[B]] with MultiMap[A, B]
How convert it to immutable?

    


Converting mutable to immutable map

I&#39;m starting to explore Scala, and one of the things I&#39;m intrigued by is the `Option` type and the promise of being able to eliminate `null` related errors.

However I haven&#39;t been able to work out how to transform a list (or other collection) of, say, `Option[String]`, to a collection of `String` (obviously filtering out any values that are `None`).

In other words, how do I get from this:

    List[Option[Int]] = List(Some(1))

... to this:

    List[Int] = List(1)

I&#39;m using Scala 2.8 if that has any impact on the answer.

How to transform Scala collection of Option[X] to collection of X

Following on from [my breathless confusion][1], what are some good resources which explain how the new [Scala][2] **2.8** collections library has been structured. I&#39;m interested to find some information on how the following fit together:

 - The collection classes/traits themselves (e.g. `List`, `Iterable`)
 - Why the *Like* classes exist (e.g. `TraversableLike`)
 - What the companion methods are for (e.g. `List.companion`)
 - How I know what `implicit` objects are in scope at a given point

  [1]: https://stackoverflow.com/questions/1721356/scala-2-8-canbuildfrom
  [2]: http://en.wikipedia.org/wiki/Scala_%28programming_language%29


Scala 2.8 collections design tutorial

I&#39;m doing a bit of Scala gymnastics where I have `Seq[T]` in which I try to find the &quot;smallest&quot; element. This is what I do right now:

	val leastOrNone = seq.reduceOption { (best, current) =&gt;
		if (current.something &lt; best.something) current
		else best
	}

It works fine, but I&#39;m not quite satisfied - it&#39;s a bit long for such a simple thing, and [I don&#39;t care much for &quot;if&quot;s][1]. Using `minBy` would be much more elegant:

	val least = seq.minBy(_.something)

... but `min` and `minBy` throw exceptions when the sequence is empty. Is there an idiomatic, more elegant way of finding the smallest element of a possibly empty list as an `Option`? 

  [1]: http://www.antiifcampaign.com/

Min/max with Option[T] for possibly empty Seq?

Whilst working through the Scala [exercises on Iterables][1], I encountered the following strange behaviour:

    val xs = Set(5,4,3,2,1)
    val ys = Set(1,2,3,4,5)
    xs sameElements ys       // true
    
    val xs = Set(3,2,1)
    val ys = Set(1,2,3)
    xs sameElements ys       // false - WAT?!

Surely these Sets have the same elements, and should ignore ordering; and why does this work as expected only for the larger set?

  [1]: http://scala-exercises.47deg.com/koans#iterables

Scala Sets contain the same elements, but sameElements() returns false

What is the difference between the `map` and `flatMap` functions of `Iterable`?

All Scala Collections Solutions on Gang of Coders

Total of 26 Scala Collections Solutions