Removing duplication from Duration.

I don't know what good it is to have code review if we are checking
in code like this. We must raise the bar, people. When the
justification for code being in the standard library is borderline
at best - as it is here - then the code must be of exceptional
quality. This code is not of exceptional quality.

Mostly these are not behavioral changes, but:

 - I removed finite_? as it is a gratuitous deviation from
   every isXXX method in the world.  This isn't ruby.
 - I removed all the regexps, which only made things complicated
 - I removed all the unnecessary casts, which is to say, all of them
 - I made more things final, sealed, and private
 - The unapply structure was all wrong; returning Option[Duration]
   on the string unapply meant you'd have to say
     case Duration(Duration(x, y)) => ...
   So I fixed apply and unapply to be symmetric.
 - And I removed the "parse" method, since it was doing what
   apply is supposed to do.

There's a test case to exercise accessing it from java,
which also reveals what I hope are bugs.

Thanks to viktor klang for DurationConversions.

1 files changed, 178 insertions, 328 deletions

diff --git a/src/library/scala/concurrent/util/Duration.scala b/src/library/scala/concurrent/util/Duration.scala
index bab664727e..bf0f3006f1 100644
--- a/src/library/scala/concurrent/util/Duration.scala
+++ b/src/library/scala/concurrent/util/Duration.scala
@@ -26,76 +26,68 @@ object Deadline {
   def now: Deadline = Deadline(Duration(System.nanoTime, NANOSECONDS))
 }
 
+// TODO: "Inf", "PlusInf", "MinusInf", where did these names come from?
+// TODO: Duration.create(n, DAYS) == Duration(Long.MaxValue, NANOSECONDS) forall (n: Double) >= 106752d
 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 = new FiniteDuration(length,  Duration.timeUnit(unit))
+  def apply(length: Long, unit: TimeUnit): FiniteDuration   = new FiniteDuration(length, unit)
+  def apply(length: Long, unit: String): FiniteDuration     = new FiniteDuration(length,  Duration.timeUnit(unit))
 
   /**
-   * 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.
+   * Parse String into Duration.  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"`.
+   * Throws exception if format is not parseable.
    */
-  def unapply(d: Duration): Option[(Long, TimeUnit)] = {
-    if (d.finite_?) {
-      Some((d.length, d.unit))
-    } else {
-      None
+  def apply(s: String): Duration = {
+    val s1: String = s filterNot (_.isWhitespace)
+    s1 match {
+      case "Inf" | "PlusInf" | "+Inf" => Inf
+      case "MinusInf" | "-Inf"        => MinusInf
+      case _                          =>
+        val unitName = s1.reverse takeWhile (_.isLetter) reverse;
+        def length   = JDouble.parseDouble(s1 dropRight unitName.length)
+        timeUnit get unitName match {
+          case Some(unit) => Duration(length, unit)
+          case _          => sys.error("format error " + s)
+        }
     }
   }
 
-  /**
-   * 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), 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
+  // "ms milli millisecond" -> List("ms", "milli", "millis", "millisecond", "milliseconds")
+  private def words(s: String) = (s.trim split "\\s+").toList
+  private def expandLabels(labels: String): List[String] = {
+    val hd :: rest = words(labels)
+    hd :: rest.flatMap(s => List(s, s + "s"))
   }
+  private val timeUnitLabels = List(
+    DAYS         -> "d day",
+    HOURS        -> "h hour",
+    MINUTES      -> "min minute",
+    SECONDS      -> "s sec second",
+    MILLISECONDS -> "ms milli millisecond",
+    MICROSECONDS -> "µs micro microsecond",
+    NANOSECONDS  -> "ns nano nanosecond"
+  )
+
+  // TimeUnit => standard label
+  protected[util] val timeUnitName: Map[TimeUnit, String] =
+    timeUnitLabels.toMap mapValues (s => words(s).last) toMap
+
+  // Label => TimeUnit
+  protected[util] val timeUnit: Map[String, TimeUnit] =
+    timeUnitLabels flatMap { case (unit, names) => expandLabels(names) map (_ -> unit) } toMap
+
+  def unapply(s: String): Option[(Long, TimeUnit)] =
+    ( try Some(apply(s)) catch { case _: RuntimeException => None } ) flatMap unapply
+
+  def unapply(d: Duration): Option[(Long, TimeUnit)] =
+    if (d.isFinite) Some((d.length, d.unit)) else None
 
   def fromNanos(nanos: Double): FiniteDuration =
-    fromNanos((nanos + 0.5).asInstanceOf[Long])
+    fromNanos((nanos + 0.5).toLong)
 
   def fromNanos(nanos: Long): FiniteDuration = {
     if (nanos % 86400000000000L == 0) {
@@ -118,72 +110,62 @@ object Duration {
   /**
    * Parse TimeUnit from string representation.
    */
-  protected[util] def timeUnit(unit: String): TimeUnit = 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: FiniteDuration = new FiniteDuration(0, NANOSECONDS)
-  val Undefined: Duration = new Duration with Infinite {
+
+  object Undefined extends Infinite {
+    private def fail(what: String) = throw new IllegalArgumentException(s"cannot $what Undefined duration")
+
     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")
+    override def equals(other: Any) = this eq other.asInstanceOf[AnyRef]
+    override def +(other: Duration): Duration = fail("add")
+    override def -(other: Duration): Duration = fail("subtract")
+    override def *(factor: Double): Duration  = fail("multiply")
+    override def /(factor: Double): Duration  = fail("divide")
+    override def /(other: Duration): Double   = fail("divide")
+    def compare(other: Duration) = fail("compare")
+    def unary_- : Duration = fail("negate")
   }
 
-  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
-      }
+  sealed abstract class Infinite extends Duration {
+    def +(other: Duration): Duration = other match {
+      case x: Infinite if x ne this => throw new IllegalArgumentException("illegal addition of infinities")
+      case _                        => this
+    }
+    // Is this really intended to throw if the argument is "this" but otherwise return this?
     def -(other: Duration): Duration =
-      other match {
-        case _: this.type => throw new IllegalArgumentException("illegal subtraction of infinities")
-        case _            => this
-      }
+      if (other ne this) this
+      else throw new IllegalArgumentException("illegal subtraction of infinities")
+
     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 /(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)
+    }
+
+    final def isFinite() = false
 
+    private def fail(what: String) = throw new IllegalArgumentException(s"$what not allowed on infinite Durations")
+    def length: Long    = fail("length")
+    def toNanos: Long   = fail("toNanos")
+    def toMicros: Long  = fail("toMicros")
+    def toMillis: Long  = fail("toMillis")
+    def toSeconds: Long = fail("toSeconds")
+    def toMinutes: Long = fail("toMinutes")
+    def toHours: Long   = fail("toHours")
+    def toDays: Long    = fail("toDays")
+
+    def unit: TimeUnit                 = fail("unit")
+    def toUnit(unit: TimeUnit): Double = fail("toUnit")
   }
 
   /**
    * Infinite duration: greater than any other and not equal to any other,
    * including itself.
    */
-  val Inf: Duration = new Duration with Infinite {
+  val Inf: Infinite = new Infinite {
     override def toString = "Duration.Inf"
     def compare(other: Duration) = if (other eq this) 0 else 1
     def unary_- : Duration = MinusInf
@@ -193,17 +175,17 @@ object Duration {
    * Infinite negative duration: lesser than any other and not equal to any other,
    * including itself.
    */
-  val MinusInf: Duration = new Duration with Infinite {
+  val MinusInf: Infinite = new 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: 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
+  def create(length: Long, unit: String): FiniteDuration     = apply(length, unit)
+  def create(s: String): Duration                            = apply(s)
 
   implicit object DurationIsOrdered extends Ordering[Duration] {
     def compare(a: Duration, b: Duration) = a compare b
@@ -261,23 +243,22 @@ abstract class Duration extends Serializable with Ordered[Duration] {
   def /(factor: Double): Duration
   def /(other: Duration): Double
   def unary_- : Duration
-  def finite_? : Boolean
+  def isFinite(): 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 div(factor: Double)    = this / factor
+  def div(other: Duration)   = this / other
+  def gt(other: Duration)    = this > other
+  def gteq(other: Duration)  = this >= other
+  def lt(other: Duration)    = this < other
+  def lteq(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_?
+  def mul(factor: Double)    = this * factor
+  def neg()                  = -this
+  def plus(other: Duration)  = this + other
 }
 
 object FiniteDuration {
@@ -286,252 +267,121 @@ object FiniteDuration {
   }
 
   def apply(length: Long, unit: TimeUnit) = new FiniteDuration(length, unit)
-
-  def apply(length: Long, unit: String) = new FiniteDuration(length, Duration.timeUnit(unit))
-
+  def apply(length: Long, unit: String)   = new FiniteDuration(length, Duration.timeUnit(unit))
 }
 
 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 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 toHours   = unit.toHours(length)
+  def toDays    = unit.toDays(length)
   def toUnit(u: TimeUnit) = toNanos.toDouble / 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 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)
+  private def unitString = timeUnitName(unit) + ( if (length == 1) "" else "s" )
+  override def toString = "" + length + " " + unitString
 
-  def +(other: Duration) = {
-    if (!other.finite_?) {
-      other
-    } else {
-      val nanos = toNanos + other.asInstanceOf[FiniteDuration].toNanos
-      fromNanos(nanos)
-    }
+  def compare(other: Duration) = other match {
+    case x: FiniteDuration => toNanos compare x.toNanos
+    case _                 => -(other compare this)
   }
-
-  def -(other: Duration) = {
-    if (!other.finite_?) {
-      other
-    } else {
-      val nanos = toNanos - other.asInstanceOf[FiniteDuration].toNanos
-      fromNanos(nanos)
-    }
+  def +(other: Duration) = other match {
+    case x: FiniteDuration => fromNanos(toNanos + x.toNanos)
+    case _                 => other
+  }
+  def -(other: Duration) = other match {
+    case x: FiniteDuration => fromNanos(toNanos - x.toNanos)
+    case _                 => other
   }
 
   def *(factor: Double) = fromNanos(toNanos.toDouble * factor)
 
   def /(factor: Double) = fromNanos(toNanos.toDouble / factor)
 
-  def /(other: Duration) = if (other.finite_?) toNanos.toDouble / other.toNanos else 0
+  def /(other: Duration) = if (other.isFinite) toNanos.toDouble / 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
+  final def isFinite() = true
 
-  override def hashCode = toNanos.asInstanceOf[Int]
+  override def equals(other: Any) = other match {
+    case x: FiniteDuration => toNanos == x.toNanos
+    case _                 => super.equals(other)
+  }
+  override def hashCode = toNanos.toInt
 }
 
-class DurationInt(n: Int) {
+trait DurationConversions extends Any {
   import duration.Classifier
+  protected def durationIn(unit: TimeUnit): FiniteDuration
 
-  def nanoseconds = Duration(n, NANOSECONDS)
-  def nanos = Duration(n, NANOSECONDS)
-  def nanosecond = Duration(n, NANOSECONDS)
-  def nano = Duration(n, NANOSECONDS)
+  def nanoseconds  = durationIn(NANOSECONDS)
+  def nanos        = nanoseconds
+  def nanosecond   = nanoseconds
+  def nano         = nanoseconds
 
-  def microseconds = Duration(n, MICROSECONDS)
-  def micros = Duration(n, MICROSECONDS)
-  def microsecond = Duration(n, MICROSECONDS)
-  def micro = Duration(n, MICROSECONDS)
+  def microseconds = durationIn(MICROSECONDS)
+  def micros       = microseconds
+  def microsecond  = microseconds
+  def micro        = microseconds
 
-  def milliseconds = Duration(n, MILLISECONDS)
-  def millis = Duration(n, MILLISECONDS)
-  def millisecond = Duration(n, MILLISECONDS)
-  def milli = Duration(n, MILLISECONDS)
+  def milliseconds = durationIn(MILLISECONDS)
+  def millis       = milliseconds
+  def millisecond  = milliseconds
+  def milli        = milliseconds
 
-  def seconds = Duration(n, SECONDS)
-  def second = Duration(n, SECONDS)
+  def seconds      = durationIn(SECONDS)
+  def second       = seconds
 
-  def minutes = Duration(n, MINUTES)
-  def minute = Duration(n, MINUTES)
+  def minutes      = durationIn(MINUTES)
+  def minute       = minutes
 
-  def hours = Duration(n, HOURS)
-  def hour =  Duration(n, HOURS)
+  def hours        = durationIn(HOURS)
+  def hour         = hours
 
-  def days = Duration(n, DAYS)
-  def day = Duration(n, DAYS)
+  def days         = durationIn(DAYS)
+  def day          = days
 
-  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 nanoseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(nanoseconds)
+  def nanos[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = nanoseconds(c)
+  def nanosecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = nanoseconds(c)
+  def nano[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = nanoseconds(c)
 
-  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 microseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(microseconds)
+  def micros[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = microseconds(c)
+  def microsecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = microseconds(c)
+  def micro[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = microseconds(c)
 
-  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 milliseconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(milliseconds)
+  def millis[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = milliseconds(c)
+  def millisecond[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = milliseconds(c)
+  def milli[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = milliseconds(c)
 
-  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 seconds[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(seconds)
+  def second[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = seconds(c)
 
-  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
+  def minutes[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(minutes)
+  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = minutes(c)
 
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
+  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(hours)
+  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = hours(c)
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
+  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(days)
+  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = days(c)
 }
 
-class DurationLong(n: Long) {
-  import duration.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, 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)
-
-  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, MINUTES))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, MINUTES))
-
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, HOURS))
-
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(n, DAYS))
+final class DurationInt(val n: Int) extends AnyVal with DurationConversions {
+  override protected def durationIn(unit: TimeUnit): FiniteDuration = Duration(n, unit)
 }
 
-class DurationDouble(d: Double) {
-  import duration.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, 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)
-
-  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, MINUTES))
-  def minute[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, MINUTES))
-
-  def hours[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, HOURS))
-  def hour[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, HOURS))
+final class DurationLong(val n: Long) extends AnyVal with DurationConversions {
+  override protected def durationIn(unit: TimeUnit): FiniteDuration = Duration(n, unit)
+}
 
-  def days[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, DAYS))
-  def day[C, CC <: Classifier[C]](c: C)(implicit ev: CC): CC#R = ev.convert(Duration(d, DAYS))
+final class DurationDouble(val d: Double) extends AnyVal with DurationConversions {
+  override protected def durationIn(unit: TimeUnit): FiniteDuration = Duration(d, unit)
 }