scala-2.8

I've seen several Scala questions recently (e.g. here , here , and here ) that called for the use of proxies, and it's come up more than once in my own work. The Scala library has a number of proxy traits (14, if I counted correctly). Proxy classes/traits usually contain lots of boilerplate: class FooProxy(val self: Foo) extends Foo { // added behavior def mymethod = ... // forwarding methods def method1 = self.method1 def method2(arg: String) = self.method2(arg) ... } trait Foo { def method1: Unit def method2(arg: String): Unit } My first thought was to define a Proxy[T] trait that could be

I'm just starting to use Apache Buildr and I'm constantly running into the problem of not knowing what repo urls and versions are available for me to use. For example I want to use Scala 2.8 in a build file, the id i previously used was: 2.8.0-SNAPSHOT But now this is not found. I also want to use the latest version of Apache POI. If I look on the maven2 repo: http://mirrors.ibiblio.org/maven2/ I can see that it only has up to version 3.2. Is there any standard way of finding repos and searching them for what they have available? Is there any standard way of finding repos and searching them

What are package objects, not so much the concept but their usage? I've tried to get an example working and the only form I got to work was as follows: package object investigations { val PackageObjectVal = "A package object val" } package investigations { object PackageObjectTest { def main(args: Array[String]) { println("Referencing a package object val: " + PackageObjectVal) } } } Observations I've made so far are: package object _root_ { ... } is disallowed (which is reasonable), package object x.y { ... } is also disallowed. It seems that a package object must be declared in the immediate

How can I convert immutable.Map to mutable.Map in Scala so I can update the values in Map? The cleanest way would be to use the mutable.Map varargs factory. Unlike the ++ approach, this uses the CanBuildFrom mechanism, and so has the potential to be more efficient if library code was written to take advantage of this: val m = collection.immutable.Map(1->"one",2->"Two") val n = collection.mutable.Map(m.toSeq: _*) This works because a Map can also be viewed as a sequence of Pairs. val myImmutableMap = collection.immutable.Map(1->"one",2->"two") val myMutableMap = collection.mutable.Map() ++

This is the same question for older version of Scala, but they say that Eclipse plugin has been improved vastly. Is it the best IDE now? How do different Scala IDE compare today? I've been pretty successful with IDEA 9. I've briefly tried both Netbeans and Eclipse and wasn't able to get what I wanted. Eclipse's code-complete didn't behave as well as I'd have liked, and I couldn't find a way to make Netbeans handle Scala scripts; It'd just complain that the file wasn't a class. To be clear, I've been using IDEA for a few years for Java, so keep that in mind:) For the moment, Scala Plugin in

@uncheckedVariance can be used to bridge the gap between Scala's declaration site variance annotations and Java's invariant generics. scala> import java.util.Comparator import java.util.Comparator scala> trait Foo[T] extends Comparator[T] defined trait Foo scala> trait Foo[-T] extends Comparator[T] <console>:5: error: contravariant type T occurs in invariant position in type [-T]java.lang.Object with java.util.Comparator[T] of trait Foo trait Foo[-T] extends Comparator[T] ^ scala> import annotation.unchecked._ import annotation.unchecked._ scala> trait Foo[-T] extends Comparator[T