You could use zip: val ms: List[Message] = ??? val as: List[Author] = ??? var sms = for ( (m, a) <- (ms zip as)) yield new SmartMessage(m, a) If you don’t like for-comprehensions you could use map: var sms = (ms zip as).map{ case (m, a) => new SmartMessage(m, a)} Method zip creates collection … Read more
Well, you could do: mapList reduce (_ ++ _) except for the special requirement for collision. Since you do have that special requirement, perhaps the best would be doing something like this (2.8): def combine(m1: Map, m2: Map): Map = { val k1 = Set(m1.keysIterator.toList: _*) val k2 = Set(m2.keysIterator.toList: _*) val intersection = k1 … Read more
Try this: val dup = List(1,1,1,2,3,4,5,5,6,100,101,101,102) dup.groupBy(identity).collect { case (x, List(_,_,_*)) => x } The groupBy associates each distinct integer with a list of its occurrences. The collect is basically map where non-matching elements are ignored. The match pattern following case will match integers x that are associated with a list that fits the pattern … Read more
None of the other answers mention the primary reason for the difference in speed, which is that the zipped version avoids 10,000 tuple allocations. As a couple of the other answers do note, the zip version involves an intermediate array, while the zipped version doesn’t, but allocating an array for 10,000 elements isn’t what makes … Read more
If you want to use the (a, (k, v)) syntax, you need to advise the compiler to use pattern matching. Map(“first”->1, “second”->2).foldLeft(0){ case (a, (k, v)) => a+v } Note that a case statement requires curly braces.
object Joda { implicit def dateTimeOrdering: Ordering[DateTime] = Ordering.fromLessThan(_ isBefore _) } // elsewhere import Joda._ dateTimes.sorted
Use drop to remove from the front and dropRight to remove from the end. def removeFirstAndLast[A](xs: Iterable[A]) = xs.drop(1).dropRight(1) Example: removeFirstAndLast(List(“one”, “two”, “three”, “four”)) map println Output: two three
Mutability for sequences only guarantees that you’ll be able to swap out the items for different ones (via the update method), as you can with e.g. primitive arrays. It does not guarantee that you’ll be able to make the sequence larger (that’s what the Growable trait is for) or smaller (Shrinkable). Buffer is the abstract … Read more
Use the to method to convert between arbitrary collection types in Scala 2.10: scala> Array(1, 2, 3).toSeq res0: Seq[Int] = WrappedArray(1, 2, 3) scala> Array(1, 2, 3).to[collection.immutable.Seq] res1: scala.collection.immutable.Seq[Int] = Vector(1, 2, 3)
Mutable means you can alter the collection in-place. So, if you have a collection c and you append an element with +=, then c has changed, and so has every other reference to that collection. Immutable means that the collection object never changes; instead, you build new collection objects with operations such as + or … Read more