fn pub static from_micros[T: ToInt](micros: ref T) -> Duration {
  Duration(micros.to_int * MILLIS_PER_SEC)
}

fn pub static from_millis[T: ToInt](millis: ref T) -> Duration {
  Duration(millis.to_int * MICROS_PER_SEC)
}

fn pub static from_nanos[T: ToInt](nanos: ref T) -> Duration {
  Duration(nanos.to_int)
}

fn pub static from_secs[T: ToFloat](secs: ref T) -> Duration {
  Duration((secs.to_float * NANOS_PER_SEC).to_int)
}

fn pub !=(other: T) -> Bool {
  (self == other).false?
}

fn pub *(other: ref Int) -> Duration {
  Duration(@nanos * other)
}

fn pub +(other: ref Duration) -> Duration {
  Duration(@nanos + other.nanos)
}

fn pub -(other: ref Duration) -> Duration {
  Duration(@nanos - other.nanos)
}

fn pub <(other: ref T) -> Bool {
  match cmp(other) {
    case Less -> true
    case _ -> false
  }
}

fn pub <=(other: ref T) -> Bool {
  match cmp(other) {
    case Less or Equal -> true
    case _ -> false
  }
}

fn pub ==(other: ref Duration) -> Bool {
  @nanos == other.nanos
}

fn pub >(other: ref T) -> Bool {
  match cmp(other) {
    case Greater -> true
    case _ -> false
  }
}

fn pub >=(other: ref T) -> Bool {
  match cmp(other) {
    case Greater or Equal -> true
    case _ -> false
  }
}

fn pub clone -> Duration {
  Duration(@nanos)
}

fn pub cmp(other: ref Duration) -> Ordering {
  @nanos.cmp(other.nanos)
}

fn pub fmt(formatter: mut Formatter) {
  let abs = @nanos.absolute
  let write = if abs >= 1_000_000_000 {
    '${to_secs} sec'
  } else if abs >= 1_000_000 {
    '${to_millis} msec'
  } else if abs >= 1_000 {
    '${to_micros} µsec'
  } else {
    '${@nanos} nsec'
  }

  formatter.write(write)
}

fn pub to_instant -> Instant {
  Instant.new + self
}

fn pub to_micros -> Int {
  @nanos / MILLIS_PER_SEC
}

fn pub to_millis -> Int {
  @nanos / MICROS_PER_SEC
}

fn pub to_nanos -> Int {
  @nanos
}

fn pub to_secs -> Float {
  @nanos.to_float / NANOS_PER_SEC
}