scala-collections

Is there an equivalent of Nil for Set in scala? I tried using Nil as a value for Set , but I got an error (expected since the type of Nil is List ) Thanks Set.empty is that set; although you can't get at it directly, it turns out that it is just a private object in the Set companion object (called, obviously enough, EmptySet ). All that Set.empty does is return that set with a cast to the correct type. It is done this way, instead of with Nil , because sets are invariant in their parameters. Nil is List[Nothing]() , but you couldn't add anything to a Set[Nothing]() . If you need to specify the

I have reached this far: implicit def collectionExtras[A](xs: Iterable[A]) = new { def zipWith[B, C, That](ys: Iterable[B])(f: (A, B) => C)(implicit cbf: CanBuildFrom[Iterable[A], C, That]) = { val builder = cbf(xs.repr) val (i, j) = (xs.iterator, ys.iterator) while(i.hasNext && j.hasNext) { builder += f(i.next, j.next) } builder.result } } // collectionExtras: [A](xs: Iterable[A])java.lang.Object{def zipWith[B,C,That](ys: Iterable[B])(f: (A, B) => C)(implicit cbf: scala.collection.generic.CanBuildFrom[Iterable[A],C,That]): That} Vector(2, 2, 2).zipWith(Vector(4, 4, 4))(_ * _) // res3:

I find lots of people trying to do this, and asking about this but the question is always answered in terms of scala code. I need to call an API that is expecting a scala.collection.immutable.Map but I have a java.util.Map, how can I cleanly convert from the latter to the former in my java code? The compiler disagrees with the sentiment that it is an implicit conversion as it barfs on that when I try it! Thank you! Getting an immutable Scala map is a little tricky because the conversions provided by the collections library return all return mutable ones, and you can't just use toMap because it

What is the idiomatic way of a getOrElseUpdate for immutable.Map instances?. I use the snippet below, but it seems verbose and inefficient var map = Map[Key, Value]() def foo(key: Key) = { val value = map.getOrElse(key, new Value) map += key -> value value } Let me summarise your problem: You want to call a method on a immutable data structure You want it to return some value and reassign a var Because the data structure is immutable, you’ll need to return a new immutable data structure, or do the assignment inside the method, using a supplied closure So, either your signature has to look like

In the article written by Daniel Korzekwa , he said that the performance of following code: list.map(e => e*2).filter(e => e>10) is much worse than the iterative solution written using Java. Can anyone explain why? And what is the best solution for such code in Scala (I hope it's not a Java iterative version which is Scala-fied)? The reason that particular code is slow is because it's working on primitives but it's using generic operations, so the primitives have to be boxed. (This could be improved if List and its ancestors were specialized.) This will probably slow things down by a factor of

I've tried different collections in Scala to sum it's elements and they are much slower than Java sums it's arrays (with for cycle). Is there a way for Scala to be as fast as Java arrays? I've heard that in scala 2.8 arrays will be same as in java, but they are much slower in practice Indexing into arrays in a while loop is as fast in Scala as in Java. (Scala's "for" loop is not the low-level construct that Java's is, so that won't work the way you want.) Thus if in Java you see for (int i=0 ; i < array.length ; i++) sum += array(i) in Scala you should write var i=0 while (i < array.length) {

I have a sequence of key-value pairs (String, Int), and I want to group them by key into a sequence of values (i.e. Seq[(String, Int)]) => Map[String, Iterable[Int]]) ). Obviously, toMap isn't useful here, and groupBy maintains the values as tuples. The best I managed to come up with is: val seq: Seq[( String, Int )] // ... seq.groupBy( _._1 ).mapValues( _.map( _._2 ) ) Is there a cleaner way of doing this? Here's a pimp that adds a toMultiMap method to traversables. Would it solve your problem? import collection._ import mutable.Builder import generic.CanBuildFrom class TraversableOnceExt[CC,