Scala is a fantastic language that unfortunately has a tradition of having no binary compatibility between versions. The result is that library developers have to go through a lot of pain to release their software for multiple scala versions. Even though starting with scala 2.9 minor versions are binary compatible, with scala 2.10 the situation has worsened because there are now some code incompatibilities as well.
This post shows some techniques for library developers to build releases against multiple scala versions, taking care of binary and code incompatibilities.
SBT — Simple Build Tool
The only viable option I know to build cross scala versions is SBT (Simple Build Tool). I am going to assume you are somewhat familiar with SBT. The most important cross build settings in your build.sbt are (full version on Github):
scalaVersion := "2.10.1"
crossScalaVersions := Seq("2.9.1", "2.9.1-1", "2.9.2", "2.10.1")
crossVersion := CrossVersion.binary
Key scalaVersion sets the current scala version to use, key crossScalaVersions contains all scala versions to use during cross builds.
The last settings has the effect that the correct scala version is appended to the name of your artifact. ‘Correct’ in this case means the full version for scala versions 2.9.x and lower, or just the 2 highest numbers for 2.10.0 and later. So if you have a setting name := "libname", the generated artifacts will be named libname_2.9.1, libname_2.9.1-1, libname_2.9.2 and libname_2.10.
Kick of a cross build by prepending ‘+’ to your command. E.g. sbt +test.
Code incompatibilities
Scala 2.10 brings some nasty code incompatibilities. The popular Akka library for example has partly moved into the main scala library. The consequence is that code for scala 2.9 needs to depend on Akka and import akka.dispatch.Future, while code for scala 2.10 needs no additional dependencies and import scala.concurrent.Future.
Another example are the changes around concurrent maps. In 2.9 one needs to do new java.util.concurrent.ConcurrentHashMap[A, B](1024).asScala to get a scala.collection.mutable.ConcurrentMap. In Scala 2.10 you are better of with scala.collection.concurrent.TrieMap.empty to get a scala.collection.concurrent.Map. All interfaces stay the same while all names changed.
Dependency incompatibilities
To define dependencies based on the current scala version you can use the following trick:
libraryDependencies <++= (scalaVersion) { v: String =>
if (v.startsWith("2.10"))
Seq("com.yammer.metrics" % "metrics-core" % "2.1.5",
"org.specs2" %% "specs2" % "1.13" % "test")
else if (v.startsWith("2.9"))
Seq("com.yammer.metrics" % "metrics-core" % "2.1.5",
"com.typesafe.akka" % "akka-actor" % "2.0.5",
"org.specs2" %% "specs2" % "1.12.3" % "test")
else Seq()
}
Fixing code incompatibilities
If code needs to differ between scala versions, the easiest way is to have multiple source roots. E.g.:
libname/
build.sbt
src/
main/
scala/
scala_2.9/
scala_2.10/
test/
Add the following to your build.sbt to make it possible:
// The following prepends src/main/scala_2.9 or src/main/scala_2.10 to the compile path.
unmanagedSourceDirectories in Compile <<= (unmanagedSourceDirectories in Compile, sourceDirectory in Compile, scalaVersion) { (sds: Seq[java.io.File], sd: java.io.File, v: String) =>
val mainVersion = v.split("""\.""").take(2).mkString(".")
val extra = new java.io.File(sd, "scala_" + mainVersion)
(if (extra.exists) Seq(extra) else Seq()) ++ sds
}
Example code for 2.9 (full version on Github):
package nl.grons.sentries.cross
object Concurrent {
type Future[+A] = akka.dispatch.Future[A]
val Future = akka.dispatch.Future
val Await = akka.dispatch.Await
type CMap[A, B] = scala.collection.mutable.ConcurrentMap[A, B]
def defaultConcurrentMap[A,B](): CMap[A,B] = new java.util.concurrent.ConcurrentHashMap[A, B](1024).asScala
}
Example code for 2.10 (full version on Github):
package nl.grons.sentries.cross
object Concurrent {
type Future[+A] = scala.concurrent.Future[A]
val Future = scala.concurrent.Future
val Await = scala.concurrent.Await
type CMap[A, B] = scala.collection.concurrent.Map[A, B]
def defaultConcurrentMap[A,B](): CMap[A,B] = scala.collection.concurrent.TrieMap.empty
}
The rest of the code can now use the type aliases and references from here. E.g. nl.grons.sentries.cross.Concurrent.Future refers to Akka for scala 2.9 and to the standard library for scala 2.10.
Conclusions
With some hackary SBT allows you to define dependencies and source roots based on the current scala version. This allows you to overcome scala’s incompatibilities if you are a library developer that builds releases for multiple scala versions.
The techniques described in this post were developed for Sentries. The code is on Github.
