Cleaned up Duration for the standard library.

 - Removed Timeout from the library. Each library should provide its own implementation of Timeout
 - Removed duration package object and replaced it with regular object
 - Removed usages of post Java 1.5 TimeUnit members
 - Added factory methods for FiniteDuration
 - Cleaned up some unnecessary comments
 - Merged duration DSL with Duration.scala file

Review by: @phaller

14 files changed, 595 insertions, 531 deletions

diff --git a/src/library/scala/concurrent/Awaitable.scala b/src/library/scala/concurrent/Awaitable.scala
index c38e668f30..6c9995eb05 100644
--- a/src/library/scala/concurrent/Awaitable.scala
+++ b/src/library/scala/concurrent/Awaitable.scala
@@ -11,7 +11,7 @@ package scala.concurrent
 
 
 import scala.annotation.implicitNotFound
-import scala.util.Duration
+import scala.concurrent.util.Duration
 
 
 
diff --git a/src/library/scala/concurrent/ConcurrentPackageObject.scala b/src/library/scala/concurrent/ConcurrentPackageObject.scala
index 7d005838d3..3471095051 100644
--- a/src/library/scala/concurrent/ConcurrentPackageObject.scala
+++ b/src/library/scala/concurrent/ConcurrentPackageObject.scala
@@ -12,7 +12,8 @@ package scala.concurrent
 
 import java.util.concurrent.{ Executors, ExecutorService }
 import scala.concurrent.forkjoin.ForkJoinPool
-import scala.util.{ Duration, Try, Success, Failure }
+import scala.util.{ Try, Success, Failure }
+import scala.concurrent.util.Duration
 import ConcurrentPackageObject._
 
 
@@ -26,8 +27,8 @@ abstract class ConcurrentPackageObject {
     new impl.ExecutionContextImpl(getExecutorService)
 
   private[concurrent] def getExecutorService: AnyRef =
-    if (util.Properties.isJavaAtLeast("1.6")) {
-      val vendor = util.Properties.javaVmVendor
+    if (scala.util.Properties.isJavaAtLeast("1.6")) {
+      val vendor = scala.util.Properties.javaVmVendor
       if ((vendor contains "Oracle") || (vendor contains "Sun") || (vendor contains "Apple")) new ForkJoinPool
       else Executors.newCachedThreadPool()
     } else Executors.newCachedThreadPool()
diff --git a/src/library/scala/concurrent/ExecutionContext.scala b/src/library/scala/concurrent/ExecutionContext.scala
index eb1b3355c0..c4a45f9fb5 100644
--- a/src/library/scala/concurrent/ExecutionContext.scala
+++ b/src/library/scala/concurrent/ExecutionContext.scala
@@ -12,7 +12,7 @@ package scala.concurrent
 
 import java.util.concurrent.atomic.{ AtomicInteger }
 import java.util.concurrent.{ Executors, Future => JFuture, Callable }
-import scala.util.Duration
+import scala.concurrent.util.Duration
 import scala.util.{ Try, Success, Failure }
 import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveTask => FJTask, RecursiveAction, ForkJoinWorkerThread }
 import scala.collection.generic.CanBuildFrom
diff --git a/src/library/scala/concurrent/Future.scala b/src/library/scala/concurrent/Future.scala
index eb54b61db0..1dc8e38355 100644
--- a/src/library/scala/concurrent/Future.scala
+++ b/src/library/scala/concurrent/Future.scala
@@ -17,7 +17,8 @@ import java.util.{ LinkedList => JLinkedList }
 import java.{ lang => jl }
 import java.util.concurrent.atomic.{ AtomicReferenceFieldUpdater, AtomicInteger, AtomicBoolean }
 
-import scala.util.{ Timeout, Duration, Try, Success, Failure }
+import scala.util.{ Try, Success, Failure }
+import scala.concurrent.util.Duration
 import scala.Option
 
 import scala.annotation.tailrec
diff --git a/src/library/scala/concurrent/Scheduler.scala b/src/library/scala/concurrent/Scheduler.scala
index 39d798e6b4..e2eb4d69fe 100644
--- a/src/library/scala/concurrent/Scheduler.scala
+++ b/src/library/scala/concurrent/Scheduler.scala
@@ -8,7 +8,7 @@
 
 package scala.concurrent
 
-import scala.util.Duration
+import scala.concurrent.util.Duration
 
 /** A service for scheduling tasks and thunks for one-time, or periodic execution.
  */
diff --git a/src/library/scala/concurrent/default/SchedulerImpl.scala.disabled b/src/library/scala/concurrent/default/SchedulerImpl.scala.disabled
index 745d2d1a15..241efa8857 100644
--- a/src/library/scala/concurrent/default/SchedulerImpl.scala.disabled
+++ b/src/library/scala/concurrent/default/SchedulerImpl.scala.disabled
@@ -9,7 +9,7 @@
 package scala.concurrent
 package default
 
-import scala.util.Duration
+import scala.concurrent.util.Duration
 
 private[concurrent] final class SchedulerImpl extends Scheduler {
   private val timer =
diff --git a/src/library/scala/concurrent/default/TaskImpl.scala.disabled b/src/library/scala/concurrent/default/TaskImpl.scala.disabled
index 94e54cb372..50753a7154 100644
--- a/src/library/scala/concurrent/default/TaskImpl.scala.disabled
+++ b/src/library/scala/concurrent/default/TaskImpl.scala.disabled
@@ -7,7 +7,7 @@ import java.util.concurrent.atomic.AtomicReferenceFieldUpdater
 import scala.concurrent.forkjoin.{ ForkJoinPool, RecursiveAction, ForkJoinWorkerThread }
 import scala.util.Try
 import scala.util
-import scala.util.Duration
+import scala.concurrent.util.Duration
 import scala.annotation.tailrec
 
 
diff --git a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
index 7984aa02b7..dd1de2025e 100644
--- a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
+++ b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
@@ -13,7 +13,8 @@ package scala.concurrent.impl
 import java.util.concurrent.{Callable, ExecutorService}
 import scala.concurrent.forkjoin._
 import scala.concurrent.{ExecutionContext, resolver, Awaitable, body2awaitable}
-import scala.util.{ Duration, Try, Success, Failure }
+import scala.util.{ Try, Success, Failure }
+import scala.concurrent.util.{ Duration }
 import scala.collection.mutable.Stack
 
 
diff --git a/src/library/scala/concurrent/impl/Promise.scala b/src/library/scala/concurrent/impl/Promise.scala
index 0087b71ea8..3d40ae6930 100644
--- a/src/library/scala/concurrent/impl/Promise.scala
+++ b/src/library/scala/concurrent/impl/Promise.scala
@@ -14,7 +14,7 @@ import java.util.concurrent.TimeUnit.{ NANOSECONDS, MILLISECONDS }
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater
 import scala.concurrent.{Awaitable, ExecutionContext, resolve, resolver, blocking, CanAwait, TimeoutException}
 //import scala.util.continuations._
-import scala.util.Duration
+import scala.concurrent.util.Duration
 import scala.util.Try
 import scala.util
 import scala.annotation.tailrec
diff --git a/src/library/scala/concurrent/package.scala b/src/library/scala/concurrent/package.scala
index 7cc48c09b2..204b3f2673 100644
--- a/src/library/scala/concurrent/package.scala
+++ b/src/library/scala/concurrent/package.scala
@@ -8,7 +8,8 @@
 
 package scala
 
-import scala.util.{ Duration, Try, Success, Failure }
+import scala.util.{ Try, Success, Failure }
+import scala.concurrent.util.Duration
 
 /** This package object contains primitives for concurrent and parallel programming.
  */
diff --git a/src/library/scala/concurrent/util/Duration.scala b/src/library/scala/concurrent/util/Duration.scala
new file mode 100644
index 0000000000..33d034da76
--- /dev/null
+++ b/src/library/scala/concurrent/util/Duration.scala
@@ -0,0 +1,578 @@
+/**
+ * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package scala.concurrent.util
+
+import java.util.concurrent.TimeUnit
+import TimeUnit._
+import java.lang.{ Double ⇒ JDouble }
+
+object DurationImplicits {
+  trait Classifier[C] {
+    type R
+    def convert(d: FiniteDuration): R
+  }
+
+  object span
+  implicit object spanConvert extends Classifier[span.type] {
+    type R = FiniteDuration
+    def convert(d: FiniteDuration) = d
+  }
+
+  object fromNow
+  implicit object fromNowConvert extends Classifier[fromNow.type] {
+    type R = Deadline
+    def convert(d: FiniteDuration) = Deadline.now + d
+  }
+
+  implicit def intToDurationInt(n: Int) = new DurationInt(n)
+  implicit def longToDurationLong(n: Long) = new DurationLong(n)
+  implicit def doubleToDurationDouble(d: Double) = new DurationDouble(d)
+
+  implicit def pairIntToDuration(p: (Int, TimeUnit)) = Duration(p._1, p._2)
+  implicit def pairLongToDuration(p: (Long, TimeUnit)) = Duration(p._1, p._2)
+  implicit def durationToPair(d: Duration) = (d.length, d.unit)
+
+  /*
+   * Avoid reflection based invocation by using non-duck type
+   */
+  class IntMult(i: Int) {
+    def *(d: Duration) = d * i
+  }
+  implicit def intMult(i: Int) = new IntMult(i)
+
+  class LongMult(l: Long) {
+    def *(d: Duration) = d * l
+  }
+  implicit def longMult(l: Long) = new LongMult(l)
+
+  class DoubleMult(f: Double) {
+    def *(d: Duration) = d * f
+  }
+  implicit def doubleMult(f: Double) = new DoubleMult(f)
+}
+
+case class Deadline private (time: Duration) {
+  def +(other: Duration): Deadline = copy(time = time + other)
+  def -(other: Duration): Deadline = copy(time = time - other)
+  def -(other: Deadline): Duration = time - other.time
+  def timeLeft: Duration = this - Deadline.now
+  def hasTimeLeft(): Boolean = !isOverdue()
+  def isOverdue(): Boolean = (time.toNanos - System.nanoTime()) < 0
+}
+
+object Deadline {
+  def now: Deadline = Deadline(Duration(System.nanoTime, NANOSECONDS))
+}
+
+object Duration {
+  implicit def timeLeft(implicit d: Deadline): Duration = d.timeLeft
+
+  def apply(length: Long, unit: TimeUnit): FiniteDuration = new FiniteDuration(length, unit)
+  def apply(length: Double, unit: TimeUnit): FiniteDuration = fromNanos(unit.toNanos(1) * length)
+  def apply(length: Long, unit: String): FiniteDuration = {
+    val (mult, timeUnit) = Duration.timeUnit(unit)
+    new FiniteDuration(length * mult, timeUnit)
+  }
+
+  /**
+   * Construct a Duration by parsing a String. In case of a format error, a
+   * RuntimeException is thrown. See `unapply(String)` for more information.
+   */
+  def apply(s: String): Duration = unapply(s) getOrElse sys.error("format error " + s)
+
+  private val RE = ("""^\s*([\+|-]?\d+(?:\.\d+)?)\s*""" + // length part
+    "(?:" + // units are distinguished in separate match groups
+    "(d|day|days)|" +
+    "(h|hour|hours)|" +
+    "(min|minute|minutes)|" +
+    "(s|sec|second|seconds)|" +
+    "(ms|milli|millis|millisecond|milliseconds)|" +
+    "(µs|micro|micros|microsecond|microseconds)|" +
+    "(ns|nano|nanos|nanosecond|nanoseconds)" +
+    """)\s*$""").r // close the non-capturing group
+  private val REinf = """^\s*(?:\+|Plus)?Inf\s*$""".r
+  private val REminf = """^\s*(?:-|Minus)Inf\s*""".r
+
+  /**
+   * Deconstruct a Duration into `Long` length and [[java.util.concurrent.TimeUnit]] if it is a 
+   * [[scala.util.concurrent.FiniteDuration]].
+   *
+   * @param d Duration to be deconstructed.
+   */
+  def unapply(d: Duration): Option[(Long, TimeUnit)] = {
+    if (d.finite_?) {
+      Some((d.length, d.unit))
+    } else {
+      None
+    }
+  }
+
+  /**
+   * Parse String, return None if no match. Format is `"<length><unit>"`, where
+   * whitespace is allowed before, between and after the parts. Infinities are
+   * designated by `"Inf"`, `"PlusInf"`, `"+Inf"` and `"-Inf"` or `"MinusInf"`.
+   */
+  def unapply(s: String): Option[Duration] = s match {
+    case RE(length, d, h, m, s, ms, mus, ns) ⇒
+      if (d ne null)
+        Some(Duration(JDouble.parseDouble(length) * 86400, SECONDS))
+      else if (h ne null)
+        Some(Duration(JDouble.parseDouble(length) * 3600, SECONDS))
+      else if (m ne null)
+        Some(Duration(JDouble.parseDouble(length) * 60, SECONDS))
+      else if (s ne null)
+        Some(Duration(JDouble.parseDouble(length), SECONDS))
+      else if (ms ne null)
+        Some(Duration(JDouble.parseDouble(length), MILLISECONDS))
+      else if (mus ne null)
+        Some(Duration(JDouble.parseDouble(length), MICROSECONDS))
+      else if (ns ne null)
+        Some(Duration(JDouble.parseDouble(length), NANOSECONDS))
+      else
+        sys.error("made some error in regex (should not be possible)")
+    case REinf()  ⇒ Some(Inf)
+    case REminf() ⇒ Some(MinusInf)
+    case _        ⇒ None
+  }
+
+  def fromNanos(nanos: Double): FiniteDuration =
+    fromNanos((nanos + 0.5).asInstanceOf[Long])
+
+  def fromNanos(nanos: Long): FiniteDuration = {
+    if (nanos % 86400000000000L == 0) {
+      Duration(nanos / 1000000000L, SECONDS)
+    } else if (nanos % 1000000000L == 0) {
+      Duration(nanos / 1000000000L, SECONDS)
+    } else if (nanos % 1000000000L == 0) {
+      Duration(nanos / 1000000000L, SECONDS)
+    } else if (nanos % 1000000000L == 0) {
+      Duration(nanos / 1000000000L, SECONDS)
+    } else if (nanos % 1000000L == 0) {
+      Duration(nanos / 1000000L, MILLISECONDS)
+    } else if (nanos % 1000L == 0) {
+      Duration(nanos / 1000L, MICROSECONDS)
+    } else {
+      Duration(nanos, NANOSECONDS)
+    }
+  }
+
+  /**
+   * Parse TimeUnit from string representation.
+   */
+  protected[util] def timeUnit(unit: String): (Long, TimeUnit) = unit.toLowerCase match {
+    case "d" | "day" | "days"                                       ⇒ (86400, SECONDS)
+    case "h" | "hour" | "hours"                                     ⇒ (3600, SECONDS)
+    case "min" | "minute" | "minutes"                               ⇒ (60, SECONDS)
+    case "s" | "sec" | "second" | "seconds"                         ⇒ (1, SECONDS)
+    case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" ⇒ (1, MILLISECONDS)
+    case "µs" | "micro" | "micros" | "microsecond" | "microseconds" ⇒ (1, MICROSECONDS)
+    case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds"     ⇒ (1, NANOSECONDS)
+  }
+
+  val Zero: FiniteDuration = new FiniteDuration(0, NANOSECONDS)
+  val Undefined: Duration = new Duration with Infinite {
+    override def toString = "Duration.Undefined"
+    override def equals(other: Any) = other.asInstanceOf[AnyRef] eq this
+    override def +(other: Duration): Duration = throw new IllegalArgumentException("cannot add Undefined duration")
+    override def -(other: Duration): Duration = throw new IllegalArgumentException("cannot subtract Undefined duration")
+    override def *(factor: Double): Duration = throw new IllegalArgumentException("cannot multiply Undefined duration")
+    override def /(factor: Double): Duration = throw new IllegalArgumentException("cannot divide Undefined duration")
+    override def /(other: Duration): Double = throw new IllegalArgumentException("cannot divide Undefined duration")
+    def compare(other: Duration) = throw new IllegalArgumentException("cannot compare Undefined duration")
+    def unary_- : Duration = throw new IllegalArgumentException("cannot negate Undefined duration")
+  }
+
+  trait Infinite {
+    this: Duration ⇒
+
+    def +(other: Duration): Duration =
+      other match {
+        case _: this.type ⇒ this
+        case _: Infinite  ⇒ throw new IllegalArgumentException("illegal addition of infinities")
+        case _            ⇒ this
+      }
+    def -(other: Duration): Duration =
+      other match {
+        case _: this.type ⇒ throw new IllegalArgumentException("illegal subtraction of infinities")
+        case _            ⇒ this
+      }
+    def *(factor: Double): Duration = this
+    def /(factor: Double): Duration = this
+    def /(other: Duration): Double =
+      other match {
+        case _: Infinite ⇒ throw new IllegalArgumentException("illegal division of infinities")
+        // maybe questionable but pragmatic: Inf / 0 => Inf
+        case x           ⇒ Double.PositiveInfinity * (if ((this > Zero) ^ (other >= Zero)) -1 else 1)
+      }
+
+    def finite_? = false
+
+    def length: Long = throw new IllegalArgumentException("length not allowed on infinite Durations")
+    def unit: TimeUnit = throw new IllegalArgumentException("unit not allowed on infinite Durations")
+    def toNanos: Long = throw new IllegalArgumentException("toNanos not allowed on infinite Durations")
+    def toMicros: Long = throw new IllegalArgumentException("toMicros not allowed on infinite Durations")
+    def toMillis: Long = throw new IllegalArgumentException("toMillis not allowed on infinite Durations")
+    def toSeconds: Long = throw new IllegalArgumentException("toSeconds not allowed on infinite Durations")
+    def toMinutes: Long = throw new IllegalArgumentException("toMinutes not allowed on infinite Durations")
+    def toHours: Long = throw new IllegalArgumentException("toHours not allowed on infinite Durations")
+    def toDays: Long = throw new IllegalArgumentException("toDays not allowed on infinite Durations")
+    def toUnit(unit: TimeUnit): Double = throw new IllegalArgumentException("toUnit not allowed on infinite Durations")
+
+  }
+
+  /**
+   * Infinite duration: greater than any other and not equal to any other,
+   * including itself.
+   */
+  val Inf: Duration = new Duration with Infinite {
+    override def toString = "Duration.Inf"
+    def compare(other: Duration) = if (other eq this) 0 else 1
+    def unary_- : Duration = MinusInf
+  }
+
+  /**
+   * Infinite negative duration: lesser than any other and not equal to any other,
+   * including itself.
+   */
+  val MinusInf: Duration = new Duration with Infinite {
+    override def toString = "Duration.MinusInf"
+    def compare(other: Duration) = if (other eq this) 0 else -1
+    def unary_- : Duration = Inf
+  }
+
+  // Java Factories
+  def create(length: Long, unit: TimeUnit): FiniteDuration = apply(length, unit)
+  def create(length: Double, unit: TimeUnit): FiniteDuration = apply(length, unit)
+  def create(length: Long, unit: String): FiniteDuration = apply(length, unit)
+  def parse(s: String): Duration = unapply(s).get
+
+  implicit object DurationIsOrdered extends Ordering[Duration] {
+    def compare(a: Duration, b: Duration) = a compare b
+  }
+}
+
+/**
+ * Utility for working with java.util.concurrent.TimeUnit durations.
+ *
+ * <p/>
+ * Examples:
+ * <pre>
+ * import scala.concurrent.util.Duration
+ * import java.util.concurrent.TimeUnit
+ *
+ * val duration = Duration(100, MILLISECONDS)
+ * val duration = Duration(100, "millis")
+ *
+ * duration.toNanos
+ * duration < 1.second
+ * duration <= Duration.Inf
+ * </pre>
+ *
+ * <p/>
+ * Implicits are also provided for Int, Long and Double. Example usage:
+ * <pre>
+ * import scala.concurrent.util.Duration._
+ *
+ * val duration = 100 millis
+ * </pre>
+ *
+ * Extractors, parsing and arithmetic are also included:
+ * <pre>
+ * val d = Duration("1.2 µs")
+ * val Duration(length, unit) = 5 millis
+ * val d2 = d * 2.5
+ * val d3 = d2 + 1.millisecond
+ * </pre>
+ */
+abstract class Duration extends Serializable with Ordered[Duration] {
+  def length: Long
+  def unit: TimeUnit
+  def toNanos: Long
+  def toMicros: Long
+  def toMillis: Long
+  def toSeconds: Long
+  def toMinutes: Long
+  def toHours: Long
+  def toDays: Long
+  def toUnit(unit: TimeUnit): Double
+
+  def +(other: Duration): Duration
+  def -(other: Duration): Duration
+  def *(factor: Double): Duration
+  def /(factor: Double): Duration
+  def /(other: Duration): Double
+  def unary_- : Duration
+  def finite_? : Boolean
+  def min(other: Duration): Duration = if (this < other) this else other
+  def max(other: Duration): Duration = if (this > other) this else other
+  def fromNow: Deadline = Deadline.now + this
+
+  // Java API
+  def lt(other: Duration) = this < other
+  def lteq(other: Duration) = this <= other
+  def gt(other: Duration) = this > other
+  def gteq(other: Duration) = this >= other
+  def plus(other: Duration) = this + other
+  def minus(other: Duration) = this - other
+  def mul(factor: Double) = this * factor
+  def div(factor: Double) = this / factor
+  def div(other: Duration) = this / other
+  def neg() = -this
+  def isFinite() = finite_?
+}
+
+object FiniteDuration {
+  implicit object FiniteDurationIsOrdered extends Ordering[FiniteDuration] {
+    def compare(a: FiniteDuration, b: FiniteDuration) = a compare b
+  }
+
+  def apply(length: Long, unit: TimeUnit) = 
+    new FiniteDuration(length, unit)
+
+  def apply(length: Long, unit: String) = {
+    val (mult, timeUnit) = Duration.timeUnit(unit)
+    new FiniteDuration(length * mult, timeUnit)
+  }
+
+}
+
+class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
+  import Duration._
+
+  def toNanos = unit.toNanos(length)
+  def toMicros = unit.toMicros(length)
+  def toMillis = unit.toMillis(length)
+  def toSeconds = unit.toSeconds(length)
+  def toMinutes = unit.toMinutes(length)
+  def toHours = unit.toHours(length)
+  def toDays = unit.toDays(length)
+  def toUnit(u: TimeUnit) = long2double(toNanos) / NANOSECONDS.convert(1, u)
+
+  override def toString = this match {
+    case Duration(1, SECONDS)      ⇒ "1 second"
+    case Duration(x, SECONDS)      ⇒ x + " seconds"
+    case Duration(1, MILLISECONDS) ⇒ "1 millisecond"
+    case Duration(x, MILLISECONDS) ⇒ x + " milliseconds"
+    case Duration(1, MICROSECONDS) ⇒ "1 microsecond"
+    case Duration(x, MICROSECONDS) ⇒ x + " microseconds"
+    case Duration(1, NANOSECONDS)  ⇒ "1 nanosecond"
+    case Duration(x, NANOSECONDS)  ⇒ x + " nanoseconds"
+  }
+
+  def compare(other: Duration) =
+    if (other.finite_?) {
+      val me = toNanos
+      val o = other.toNanos
+      if (me > o) 1 else if (me < o) -1 else 0
+    } else -other.compare(this)
+
+  def +(other: Duration) = {
+    if (!other.finite_?) {
+      other
+    } else {
+      val nanos = toNanos + other.asInstanceOf[FiniteDuration].toNanos
+      fromNanos(nanos)
+    }
+  }
+
+  def -(other: Duration) = {
+    if (!other.finite_?) {
+      other
+    } else {
+      val nanos = toNanos - other.asInstanceOf[FiniteDuration].toNanos
+      fromNanos(nanos)
+    }
+  }
+
+  def *(factor: Double) = fromNanos(long2double(toNanos) * factor)
+
+  def /(factor: Double) = fromNanos(long2double(toNanos) / factor)
+
+  def /(other: Duration) = if (other.finite_?) long2double(toNanos) / other.toNanos else 0
+
+  def unary_- = Duration(-length, unit)
+
+  def finite_? = true
+
+  override def equals(other: Any) =
+    other.isInstanceOf[FiniteDuration] &&
+      toNanos == other.asInstanceOf[FiniteDuration].toNanos
+
+  override def hashCode = toNanos.asInstanceOf[Int]
+}
+
+class DurationInt(n: Int) {
+  import DurationImplicits.Classifier
+
+  def nanoseconds = Duration(n, NANOSECONDS)
+  def nanos = Duration(n, NANOSECONDS)
+  def nanosecond = Duration(n, NANOSECONDS)
+  def nano = Duration(n, NANOSECONDS)
+
+  def microseconds = Duration(n, MICROSECONDS)
+  def micros = Duration(n, MICROSECONDS)
+  def microsecond = Duration(n, MICROSECONDS)
+  def micro = Duration(n, MICROSECONDS)
+
+  def milliseconds = Duration(n, MILLISECONDS)
+  def millis = Duration(n, MILLISECONDS)
+  def millisecond = Duration(n, MILLISECONDS)
+  def milli = Duration(n, MILLISECONDS)
+
+  def seconds = Duration(n, SECONDS)
+  def second = Duration(n, SECONDS)
+
+  def minutes = Duration(n * 60, SECONDS)
+  def minute = Duration(n * 60, SECONDS)
+
+  def hours = Duration(n * 3600, SECONDS)
+  def hour =  Duration(n * 3600, SECONDS)
+
+  def days = Duration(n * 86400, SECONDS)
+  def day = Duration(n * 86400, SECONDS)
+
+  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+
+  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+
+  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+
+  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
+  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
+
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
+
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
+
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
+}
+
+class DurationLong(n: Long) {
+  import DurationImplicits.Classifier
+
+  def nanoseconds = Duration(n, NANOSECONDS)
+  def nanos = Duration(n, NANOSECONDS)
+  def nanosecond = Duration(n, NANOSECONDS)
+  def nano = Duration(n, NANOSECONDS)
+
+  def microseconds = Duration(n, MICROSECONDS)
+  def micros = Duration(n, MICROSECONDS)
+  def microsecond = Duration(n, MICROSECONDS)
+  def micro = Duration(n, MICROSECONDS)
+
+  def milliseconds = Duration(n, MILLISECONDS)
+  def millis = Duration(n, MILLISECONDS)
+  def millisecond = Duration(n, MILLISECONDS)
+  def milli = Duration(n, MILLISECONDS)
+
+  def seconds = Duration(n, SECONDS)
+  def second = Duration(n, SECONDS)
+
+  def minutes = Duration(n * 60, SECONDS)
+  def minute = Duration(n * 60, SECONDS)
+
+  def hours = Duration(n * 3600, SECONDS)
+  def hour = Duration(n * 3600, SECONDS)
+
+  def days = Duration(n * 86400, SECONDS)
+  def day = Duration(n * 86400, SECONDS)
+
+  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, NANOSECONDS))
+
+  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MICROSECONDS))
+
+  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MILLISECONDS))
+
+  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
+  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, SECONDS))
+
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 60, SECONDS))
+
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 3600, SECONDS))
+
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n * 86400, SECONDS))
+}
+
+class DurationDouble(d: Double) {
+  import DurationImplicits.Classifier
+
+  def nanoseconds = Duration(d, NANOSECONDS)
+  def nanos = Duration(d, NANOSECONDS)
+  def nanosecond = Duration(d, NANOSECONDS)
+  def nano = Duration(d, NANOSECONDS)
+
+  def microseconds = Duration(d, MICROSECONDS)
+  def micros = Duration(d, MICROSECONDS)
+  def microsecond = Duration(d, MICROSECONDS)
+  def micro = Duration(d, MICROSECONDS)
+
+  def milliseconds = Duration(d, MILLISECONDS)
+  def millis = Duration(d, MILLISECONDS)
+  def millisecond = Duration(d, MILLISECONDS)
+  def milli = Duration(d, MILLISECONDS)
+
+  def seconds = Duration(d, SECONDS)
+  def second = Duration(d, SECONDS)
+
+  def minutes = Duration(d * 60, SECONDS)
+  def minute = Duration(d * 60, SECONDS)
+
+  def hours = Duration(d * 3600, SECONDS)
+  def hour = Duration(d * 3600, SECONDS)
+
+  def days = Duration(d * 86400, SECONDS)
+  def day = Duration(d * 86400, SECONDS)
+
+  def nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
+  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
+  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
+  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, NANOSECONDS))
+
+  def microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
+  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
+  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
+  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MICROSECONDS))
+
+  def milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
+  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
+  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
+  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MILLISECONDS))
+
+  def seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, SECONDS))
+  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, SECONDS))
+
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 60, SECONDS))
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 60, SECONDS))
+
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 3600, SECONDS))
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 3600, SECONDS))
+
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 86400, SECONDS))
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d * 86400, SECONDS))
+}
diff --git a/src/library/scala/util/Duration.scala b/src/library/scala/util/Duration.scala
deleted file mode 100644
index 4c118f8b3b..0000000000
--- a/src/library/scala/util/Duration.scala
+++ /dev/null
@@ -1,485 +0,0 @@
-/**
- * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
- */
-
-package scala.util
-
-import java.util.concurrent.TimeUnit
-import TimeUnit._
-import java.lang.{ Long ⇒ JLong, Double ⇒ JDouble }
-//import akka.actor.ActorSystem (commented methods)
-
-class TimerException(message: String) extends RuntimeException(message)
-
-/**
- * Simple timer class.
- * Usage:
- * <pre>
- *   import akka.util.duration._
- *   import akka.util.Timer
- *
- *   val timer = Timer(30.seconds)
- *   while (timer.isTicking) { ... }
- * </pre>
- */
-case class Timer(duration: Duration, throwExceptionOnTimeout: Boolean = false) {
-  val startTimeInMillis = System.currentTimeMillis
-  val timeoutInMillis = duration.toMillis
-
-  /**
-   * Returns true while the timer is ticking. After that it either throws and exception or
-   * returns false. Depending on if the 'throwExceptionOnTimeout' argument is true or false.
-   */
-  def isTicking: Boolean = {
-    if (!(timeoutInMillis > (System.currentTimeMillis - startTimeInMillis))) {
-      if (throwExceptionOnTimeout) throw new TimerException("Time out after " + duration)
-      else false
-    } else true
-  }
-}
-
-object Duration {
-  def apply(length: Long, unit: TimeUnit): Duration = new FiniteDuration(length, unit)
-  def apply(length: Double, unit: TimeUnit): Duration = fromNanos(unit.toNanos(1) * length)
-  def apply(length: Long, unit: String): Duration = new FiniteDuration(length, timeUnit(unit))
-
-  def fromNanos(nanos: Long): Duration = {
-    if (nanos % 86400000000000L == 0) {
-      Duration(nanos / 86400000000000L, DAYS)
-    } else if (nanos % 3600000000000L == 0) {
-      Duration(nanos / 3600000000000L, HOURS)
-    } else if (nanos % 60000000000L == 0) {
-      Duration(nanos / 60000000000L, MINUTES)
-    } else if (nanos % 1000000000L == 0) {
-      Duration(nanos / 1000000000L, SECONDS)
-    } else if (nanos % 1000000L == 0) {
-      Duration(nanos / 1000000L, MILLISECONDS)
-    } else if (nanos % 1000L == 0) {
-      Duration(nanos / 1000L, MICROSECONDS)
-    } else {
-      Duration(nanos, NANOSECONDS)
-    }
-  }
-
-  def fromNanos(nanos: Double): Duration = fromNanos((nanos + 0.5).asInstanceOf[Long])
-
-  /**
-   * Construct a Duration by parsing a String. In case of a format error, a
-   * RuntimeException is thrown. See `unapply(String)` for more information.
-   */
-  def apply(s: String): Duration = unapply(s) getOrElse sys.error("format error")
-
-  /**
-   * Deconstruct a Duration into length and unit if it is finite.
-   */
-  def unapply(d: Duration): Option[(Long, TimeUnit)] = {
-    if (d.finite_?) {
-      Some((d.length, d.unit))
-    } else {
-      None
-    }
-  }
-
-  private val RE = ("""^\s*(\d+(?:\.\d+)?)\s*""" + // length part
-    "(?:" + // units are distinguished in separate match groups
-    "(d|day|days)|" +
-    "(h|hour|hours)|" +
-    "(min|minute|minutes)|" +
-    "(s|sec|second|seconds)|" +
-    "(ms|milli|millis|millisecond|milliseconds)|" +
-    "(µs|micro|micros|microsecond|microseconds)|" +
-    "(ns|nano|nanos|nanosecond|nanoseconds)" +
-    """)\s*$""").r // close the non-capturing group
-  private val REinf = """^\s*Inf\s*$""".r
-  private val REminf = """^\s*(?:-\s*|Minus)Inf\s*""".r
-
-  /**
-   * Parse String, return None if no match. Format is `"<length><unit>"`, where
-   * whitespace is allowed before, between and after the parts. Infinities are
-   * designated by `"Inf"` and `"-Inf"` or `"MinusInf"`.
-   */
-  def unapply(s: String): Option[Duration] = s match {
-    case RE(length, d, h, m, s, ms, mus, ns) ⇒
-      if (d ne null) Some(Duration(JDouble.parseDouble(length), DAYS)) else if (h ne null) Some(Duration(JDouble.parseDouble(length), HOURS)) else if (m ne null) Some(Duration(JDouble.parseDouble(length), MINUTES)) else if (s ne null) Some(Duration(JDouble.parseDouble(length), SECONDS)) else if (ms ne null) Some(Duration(JDouble.parseDouble(length), MILLISECONDS)) else if (mus ne null) Some(Duration(JDouble.parseDouble(length), MICROSECONDS)) else if (ns ne null) Some(Duration(JDouble.parseDouble(length), NANOSECONDS)) else
-        sys.error("made some error in regex (should not be possible)")
-    case REinf()  ⇒ Some(Inf)
-    case REminf() ⇒ Some(MinusInf)
-    case _        ⇒ None
-  }
-
-  /**
-   * Parse TimeUnit from string representation.
-   */
-  def timeUnit(unit: String) = unit.toLowerCase match {
-    case "d" | "day" | "days"                                       ⇒ DAYS
-    case "h" | "hour" | "hours"                                     ⇒ HOURS
-    case "min" | "minute" | "minutes"                               ⇒ MINUTES
-    case "s" | "sec" | "second" | "seconds"                         ⇒ SECONDS
-    case "ms" | "milli" | "millis" | "millisecond" | "milliseconds" ⇒ MILLISECONDS
-    case "µs" | "micro" | "micros" | "microsecond" | "microseconds" ⇒ MICROSECONDS
-    case "ns" | "nano" | "nanos" | "nanosecond" | "nanoseconds"     ⇒ NANOSECONDS
-  }
-
-  val Zero: Duration = new FiniteDuration(0, NANOSECONDS)
-  val Undefined: Duration = new Duration with Infinite {
-    override def toString = "Duration.Undefined"
-    override def equals(other: Any) = other.asInstanceOf[AnyRef] eq this
-    override def +(other: Duration): Duration = throw new IllegalArgumentException("cannot add Undefined duration")
-    override def -(other: Duration): Duration = throw new IllegalArgumentException("cannot subtract Undefined duration")
-    override def *(factor: Double): Duration = throw new IllegalArgumentException("cannot multiply Undefined duration")
-    override def /(factor: Double): Duration = throw new IllegalArgumentException("cannot divide Undefined duration")
-    override def /(other: Duration): Double = throw new IllegalArgumentException("cannot divide Undefined duration")
-    def >(other: Duration) = throw new IllegalArgumentException("cannot compare Undefined duration")
-    def >=(other: Duration) = throw new IllegalArgumentException("cannot compare Undefined duration")
-    def <(other: Duration) = throw new IllegalArgumentException("cannot compare Undefined duration")
-    def <=(other: Duration) = throw new IllegalArgumentException("cannot compare Undefined duration")
-    def unary_- : Duration = throw new IllegalArgumentException("cannot negate Undefined duration")
-  }
-
-  trait Infinite {
-    this: Duration ⇒
-
-    override def equals(other: Any) = false
-
-    def +(other: Duration): Duration =
-      other match {
-        case _: this.type ⇒ this
-        case _: Infinite  ⇒ throw new IllegalArgumentException("illegal addition of infinities")
-        case _            ⇒ this
-      }
-    def -(other: Duration): Duration =
-      other match {
-        case _: this.type ⇒ throw new IllegalArgumentException("illegal subtraction of infinities")
-        case _            ⇒ this
-      }
-    def *(factor: Double): Duration = this
-    def /(factor: Double): Duration = this
-    def /(other: Duration): Double =
-      other match {
-        case _: Infinite ⇒ throw new IllegalArgumentException("illegal division of infinities")
-        // maybe questionable but pragmatic: Inf / 0 => Inf
-        case x           ⇒ Double.PositiveInfinity * (if ((this > Zero) ^ (other >= Zero)) -1 else 1)
-      }
-
-    def finite_? = false
-
-    def length: Long = throw new IllegalArgumentException("length not allowed on infinite Durations")
-    def unit: TimeUnit = throw new IllegalArgumentException("unit not allowed on infinite Durations")
-    def toNanos: Long = throw new IllegalArgumentException("toNanos not allowed on infinite Durations")
-    def toMicros: Long = throw new IllegalArgumentException("toMicros not allowed on infinite Durations")
-    def toMillis: Long = throw new IllegalArgumentException("toMillis not allowed on infinite Durations")
-    def toSeconds: Long = throw new IllegalArgumentException("toSeconds not allowed on infinite Durations")
-    def toMinutes: Long = throw new IllegalArgumentException("toMinutes not allowed on infinite Durations")
-    def toHours: Long = throw new IllegalArgumentException("toHours not allowed on infinite Durations")
-    def toDays: Long = throw new IllegalArgumentException("toDays not allowed on infinite Durations")
-    def toUnit(unit: TimeUnit): Double = throw new IllegalArgumentException("toUnit not allowed on infinite Durations")
-
-    def printHMS = toString
-  }
-
-  /**
-   * Infinite duration: greater than any other and not equal to any other,
-   * including itself.
-   */
-  val Inf: Duration = new Duration with Infinite {
-    override def toString = "Duration.Inf"
-    def >(other: Duration) = true
-    def >=(other: Duration) = true
-    def <(other: Duration) = false
-    def <=(other: Duration) = false
-    def unary_- : Duration = MinusInf
-  }
-
-  /**
-   * Infinite negative duration: lesser than any other and not equal to any other,
-   * including itself.
-   */
-  val MinusInf: Duration = new Duration with Infinite {
-    override def toString = "Duration.MinusInf"
-    def >(other: Duration) = false
-    def >=(other: Duration) = false
-    def <(other: Duration) = true
-    def <=(other: Duration) = true
-    def unary_- : Duration = Inf
-  }
-
-  // Java Factories
-  def create(length: Long, unit: TimeUnit): Duration = apply(length, unit)
-  def create(length: Double, unit: TimeUnit): Duration = apply(length, unit)
-  def create(length: Long, unit: String): Duration = apply(length, unit)
-  def parse(s: String): Duration = unapply(s).get
-}
-
-/**
- * Utility for working with java.util.concurrent.TimeUnit durations.
- *
- * <p/>
- * Examples of usage from Java:
- * <pre>
- * import akka.util.FiniteDuration;
- * import java.util.concurrent.TimeUnit;
- *
- * Duration duration = new FiniteDuration(100, MILLISECONDS);
- * Duration duration = new FiniteDuration(5, "seconds");
- *
- * duration.toNanos();
- * </pre>
- *
- * <p/>
- * Examples of usage from Scala:
- * <pre>
- * import akka.util.Duration
- * import java.util.concurrent.TimeUnit
- *
- * val duration = Duration(100, MILLISECONDS)
- * val duration = Duration(100, "millis")
- *
- * duration.toNanos
- * duration < 1.second
- * duration <= Duration.Inf
- * </pre>
- *
- * <p/>
- * Implicits are also provided for Int, Long and Double. Example usage:
- * <pre>
- * import akka.util.duration._
- *
- * val duration = 100 millis
- * </pre>
- *
- * Extractors, parsing and arithmetic are also included:
- * <pre>
- * val d = Duration("1.2 µs")
- * val Duration(length, unit) = 5 millis
- * val d2 = d * 2.5
- * val d3 = d2 + 1.millisecond
- * </pre>
- */
-abstract class Duration extends Serializable {
-  def length: Long
-  def unit: TimeUnit
-  def toNanos: Long
-  def toMicros: Long
-  def toMillis: Long
-  def toSeconds: Long
-  def toMinutes: Long
-  def toHours: Long
-  def toDays: Long
-  def toUnit(unit: TimeUnit): Double
-  def printHMS: String
-  def <(other: Duration): Boolean
-  def <=(other: Duration): Boolean
-  def >(other: Duration): Boolean
-  def >=(other: Duration): Boolean
-  def +(other: Duration): Duration
-  def -(other: Duration): Duration
-  def *(factor: Double): Duration
-  def /(factor: Double): Duration
-  def /(other: Duration): Double
-  def unary_- : Duration
-  def finite_? : Boolean
-//  def dilated(implicit system: ActorSystem): Duration = this * system.settings.TestTimeFactor
-  def min(other: Duration): Duration = if (this < other) this else other
-  def max(other: Duration): Duration = if (this > other) this else other
-  def sleep(): Unit = Thread.sleep(toMillis)
-
-  // Java API
-  def lt(other: Duration) = this < other
-  def lteq(other: Duration) = this <= other
-  def gt(other: Duration) = this > other
-  def gteq(other: Duration) = this >= other
-  def plus(other: Duration) = this + other
-  def minus(other: Duration) = this - other
-  def mul(factor: Double) = this * factor
-  def div(factor: Double) = this / factor
-  def div(other: Duration) = this / other
-  def neg() = -this
-  def isFinite() = finite_?
-}
-
-class FiniteDuration(val length: Long, val unit: TimeUnit) extends Duration {
-  import Duration._
-
-  def this(length: Long, unit: String) = this(length, Duration.timeUnit(unit))
-
-  def toNanos = unit.toNanos(length)
-  def toMicros = unit.toMicros(length)
-  def toMillis = unit.toMillis(length)
-  def toSeconds = unit.toSeconds(length)
-  def toMinutes = unit.toMinutes(length)
-  def toHours = unit.toHours(length)
-  def toDays = unit.toDays(length)
-  def toUnit(u: TimeUnit) = long2double(toNanos) / NANOSECONDS.convert(1, u)
-
-  override def toString = this match {
-    case Duration(1, DAYS)         ⇒ "1 day"
-    case Duration(x, DAYS)         ⇒ x + " days"
-    case Duration(1, HOURS)        ⇒ "1 hour"
-    case Duration(x, HOURS)        ⇒ x + " hours"
-    case Duration(1, MINUTES)      ⇒ "1 minute"
-    case Duration(x, MINUTES)      ⇒ x + " minutes"
-    case Duration(1, SECONDS)      ⇒ "1 second"
-    case Duration(x, SECONDS)      ⇒ x + " seconds"
-    case Duration(1, MILLISECONDS) ⇒ "1 millisecond"
-    case Duration(x, MILLISECONDS) ⇒ x + " milliseconds"
-    case Duration(1, MICROSECONDS) ⇒ "1 microsecond"
-    case Duration(x, MICROSECONDS) ⇒ x + " microseconds"
-    case Duration(1, NANOSECONDS)  ⇒ "1 nanosecond"
-    case Duration(x, NANOSECONDS)  ⇒ x + " nanoseconds"
-  }
-
-  def printHMS = "%02d:%02d:%06.3f".format(toHours, toMinutes % 60, toMillis / 1000.0 % 60)
-
-  def <(other: Duration) = {
-    if (other.finite_?) {
-      toNanos < other.asInstanceOf[FiniteDuration].toNanos
-    } else {
-      other > this
-    }
-  }
-
-  def <=(other: Duration) = {
-    if (other.finite_?) {
-      toNanos <= other.asInstanceOf[FiniteDuration].toNanos
-    } else {
-      other >= this
-    }
-  }
-
-  def >(other: Duration) = {
-    if (other.finite_?) {
-      toNanos > other.asInstanceOf[FiniteDuration].toNanos
-    } else {
-      other < this
-    }
-  }
-
-  def >=(other: Duration) = {
-    if (other.finite_?) {
-      toNanos >= other.asInstanceOf[FiniteDuration].toNanos
-    } else {
-      other <= this
-    }
-  }
-
-  def +(other: Duration) = {
-    if (!other.finite_?) {
-      other
-    } else {
-      val nanos = toNanos + other.asInstanceOf[FiniteDuration].toNanos
-      fromNanos(nanos)
-    }
-  }
-
-  def -(other: Duration) = {
-    if (!other.finite_?) {
-      other
-    } else {
-      val nanos = toNanos - other.asInstanceOf[FiniteDuration].toNanos
-      fromNanos(nanos)
-    }
-  }
-
-  def *(factor: Double) = fromNanos(long2double(toNanos) * factor)
-
-  def /(factor: Double) = fromNanos(long2double(toNanos) / factor)
-
-  def /(other: Duration) = if (other.finite_?) long2double(toNanos) / other.toNanos else 0
-
-  def unary_- = Duration(-length, unit)
-
-  def finite_? = true
-
-  override def equals(other: Any) =
-    other.isInstanceOf[FiniteDuration] &&
-      toNanos == other.asInstanceOf[FiniteDuration].toNanos
-
-  override def hashCode = toNanos.asInstanceOf[Int]
-}
-
-class DurationInt(n: Int) {
-  def nanoseconds = Duration(n, NANOSECONDS)
-  def nanos = Duration(n, NANOSECONDS)
-  def nanosecond = Duration(n, NANOSECONDS)
-  def nano = Duration(n, NANOSECONDS)
-
-  def microseconds = Duration(n, MICROSECONDS)
-  def micros = Duration(n, MICROSECONDS)
-  def microsecond = Duration(n, MICROSECONDS)
-  def micro = Duration(n, MICROSECONDS)
-
-  def milliseconds = Duration(n, MILLISECONDS)
-  def millis = Duration(n, MILLISECONDS)
-  def millisecond = Duration(n, MILLISECONDS)
-  def milli = Duration(n, MILLISECONDS)
-
-  def seconds = Duration(n, SECONDS)
-  def second = Duration(n, SECONDS)
-
-  def minutes = Duration(n, MINUTES)
-  def minute = Duration(n, MINUTES)
-
-  def hours = Duration(n, HOURS)
-  def hour = Duration(n, HOURS)
-
-  def days = Duration(n, DAYS)
-  def day = Duration(n, DAYS)
-}
-
-class DurationLong(n: Long) {
-  def nanoseconds = Duration(n, NANOSECONDS)
-  def nanos = Duration(n, NANOSECONDS)
-  def nanosecond = Duration(n, NANOSECONDS)
-  def nano = Duration(n, NANOSECONDS)
-
-  def microseconds = Duration(n, MICROSECONDS)
-  def micros = Duration(n, MICROSECONDS)
-  def microsecond = Duration(n, MICROSECONDS)
-  def micro = Duration(n, MICROSECONDS)
-
-  def milliseconds = Duration(n, MILLISECONDS)
-  def millis = Duration(n, MILLISECONDS)
-  def millisecond = Duration(n, MILLISECONDS)
-  def milli = Duration(n, MILLISECONDS)
-
-  def seconds = Duration(n, SECONDS)
-  def second = Duration(n, SECONDS)
-
-  def minutes = Duration(n, MINUTES)
-  def minute = Duration(n, MINUTES)
-
-  def hours = Duration(n, HOURS)
-  def hour = Duration(n, HOURS)
-
-  def days = Duration(n, DAYS)
-  def day = Duration(n, DAYS)
-}
-
-class DurationDouble(d: Double) {
-  def nanoseconds = Duration(d, NANOSECONDS)
-  def nanos = Duration(d, NANOSECONDS)
-  def nanosecond = Duration(d, NANOSECONDS)
-  def nano = Duration(d, NANOSECONDS)
-
-  def microseconds = Duration(d, MICROSECONDS)
-  def micros = Duration(d, MICROSECONDS)
-  def microsecond = Duration(d, MICROSECONDS)
-  def micro = Duration(d, MICROSECONDS)
-
-  def milliseconds = Duration(d, MILLISECONDS)
-  def millis = Duration(d, MILLISECONDS)
-  def millisecond = Duration(d, MILLISECONDS)
-  def milli = Duration(d, MILLISECONDS)
-
-  def seconds = Duration(d, SECONDS)
-  def second = Duration(d, SECONDS)
-
-  def minutes = Duration(d, MINUTES)
-  def minute = Duration(d, MINUTES)
-
-  def hours = Duration(d, HOURS)
-  def hour = Duration(d, HOURS)
-
-  def days = Duration(d, DAYS)
-  def day = Duration(d, DAYS)
-}
diff --git a/src/library/scala/util/Timeout.scala b/src/library/scala/util/Timeout.scala
deleted file mode 100644
index 0190675344..0000000000
--- a/src/library/scala/util/Timeout.scala
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
- */
-package scala.util
-
-import java.util.concurrent.TimeUnit
-
-case class Timeout(duration: Duration) {
-  def this(timeout: Long) = this(Duration(timeout, TimeUnit.MILLISECONDS))
-  def this(length: Long, unit: TimeUnit) = this(Duration(length, unit))
-}
-
-object Timeout {
-  /**
-   * A timeout with zero duration, will cause most requests to always timeout.
-   */
-  val zero = new Timeout(Duration.Zero)
-
-  /**
-   * A Timeout with infinite duration. Will never timeout. Use extreme caution with this
-   * as it may cause memory leaks, blocked threads, or may not even be supported by
-   * the receiver, which would result in an exception.
-   */
-  val never = new Timeout(Duration.Inf)
-
-  def apply(timeout: Long) = new Timeout(timeout)
-  def apply(length: Long, unit: TimeUnit) = new Timeout(length, unit)
-
-  implicit def durationToTimeout(duration: Duration) = new Timeout(duration)
-  implicit def intToTimeout(timeout: Int) = new Timeout(timeout)
-  implicit def longToTimeout(timeout: Long) = new Timeout(timeout)
-  //implicit def defaultTimeout(implicit system: ActorSystem) = system.settings.ActorTimeout (have to introduce this in ActorSystem)
-}
diff --git a/test/files/jvm/scala-concurrent-tck.scala b/test/files/jvm/scala-concurrent-tck.scala
index ba7dffbcb0..70221c0de1 100644
--- a/test/files/jvm/scala-concurrent-tck.scala
+++ b/test/files/jvm/scala-concurrent-tck.scala
@@ -13,7 +13,7 @@ import scala.concurrent.promise
 import scala.concurrent.blocking
 import scala.util.{ Try, Success, Failure }
 
-import scala.util.Duration
+import scala.concurrent.util.Duration
 
 
 trait TestBase {