seq.reduceOption(_ min _) does what you want? Edit: Here’s an example incorporating your _.something: case class Foo(a: Int, b: Int) val seq = Seq(Foo(1,1),Foo(2,0),Foo(0,3)) val ord = Ordering.by((_: Foo).b) seq.reduceOption(ord.min) //Option[Foo] = Some(Foo(2,0)) or, as generic method: def minOptionBy[A, B: Ordering](seq: Seq[A])(f: A => B) = seq reduceOption Ordering.by(f).min which you could invoke with minOptionBy(seq)(_.something)
Foreword There’s a 2.8 collection walk-through by Martin Odersky which should probably be your first reference. It has been supplemented as well with architectural notes, which will be of particular interest to those who want to design their own collections. The rest of this answer was written way before any such thing existed (in fact, … Read more
val list1 = List(Some(1), None, Some(2)) val list2 = list1.flatten // will be: List(1,2)
The immutable hierarchy doesn’t contain a MultiMap, so you won’t be able to use the converted structure with the same convenient syntax. But if you’re happy to deal with key/valueset pairs, then: If you just want a mutable HashMap, you can just use x.toMap in 2.8 or collection.immutable.Map(x.toList: _*) in 2.7. But if you want … Read more
From the Scala docs: Note: the difference between c filter p and c withFilter p is that the former creates a new collection, whereas the latter only restricts the domain of subsequent map, flatMap, foreach, and withFilter operations. So filter will take the original collection and produce a new collection, but withFilter will non-strictly (i.e. … Read more
For future reference: With Scala 2.8, it could be done like this: import scala.collection.JavaConversions._ val list = new java.util.ArrayList[String]() list.add(“test”) val set = list.toSet set is a scala.collection.immutable.Set[String] after this. Also see Ben James’ answer for a more explicit way (using JavaConverters), which seems to be recommended now.
Set is invariant in its type parameter because of the concept behind sets as functions. The following signatures should clarify things slightly: trait Set[A] extends (A=>Boolean) { def apply(e: A): Boolean } If Set were covariant in A, the apply method would be unable to take a parameter of type A due to the contravariance … Read more
Assuming values are unique, this works: (Map() ++ origMap.map(_.swap)) On Scala 2.8, however, it’s easier: origMap.map(_.swap) Being able to do that is part of the reason why Scala 2.8 has a new collection library.
You can call the slice method: scala> Array(“foo”, “hoo”, “goo”, “ioo”, “joo”).slice(1, 4) res6: Array[java.lang.String] = Array(hoo, goo, ioo) It works like in python.
Think of it as the difference between blowing and sucking. When you have call a Traversables foreach, or its derived methods, it will blow its values into your function one at a time – so it has control over the iteration. With the Iterator returned by an Iterable though, you suck the values out of … Read more