How do I compare two timeout values in milliseconds in EK9?

  shortTimeout <- 250ms
  longTimeout <- 5000ms

  if shortTimeout < longTimeout   shorter timeout
  ordering <- shortTimeout <=> longTimeout

  quickest <- shortTimeout <? longTimeout  returns the shorter
  slowest <- shortTimeout >? longTimeout   returns the longer

defines module qa.operators.millisecondcompare

  defines function

    <?- Compare two millisecond values and return spaceship ordering. -?>
    compareMs() as pure
      ->
        left as Millisecond
        right as Millisecond
      <- rtn as Integer: left <=> right

    <?- Check if the first timeout is shorter than the second. -?>
    isShorter() as pure
      ->
        left as Millisecond
        right as Millisecond
      <- rtn as Boolean: left < right

    <?- Return the quicker of two timeouts using coalescing min. -?>
    quickerOf() as pure
      ->
        left as Millisecond
        right as Millisecond
      <- rtn as Millisecond: left <? right

    <?- Return the slower of two timeouts using coalescing max. -?>
    slowerOf() as pure
      ->
        left as Millisecond
        right as Millisecond
      <- rtn as Millisecond: left >? right

  defines program

    MillisecondCompareDemo()
      stdout <- Stdout()

      // === MILLISECOND LITERALS ===

      shortTimeout <- 250ms
      longTimeout <- 5000ms
      mediumTimeout <- 1500ms

      // === COMPARISON VIA FUNCTION ===

      shorter <- isShorter(shortTimeout, longTimeout)
      stdout.println(`Short is faster: ${shorter}`)

      // === SPACESHIP ORDERING VIA FUNCTION ===

      ordering <- compareMs(shortTimeout, longTimeout)
      stdout.println(`Short <=> Long: ${ordering}`)

      mediumOrder <- compareMs(mediumTimeout, longTimeout)
      stdout.println(`Medium <=> Long: ${mediumOrder}`)

      // === COALESCING: FIND QUICKEST AND SLOWEST ===

      quickest <- quickerOf(shortTimeout, longTimeout)
      slowest <- slowerOf(shortTimeout, longTimeout)
      stdout.println(`Quickest: ${quickest}`)
      stdout.println(`Slowest: ${slowest}`)

      // === SORTED TIMEOUT LIST VIA STREAM ===

      timeouts <- List() of Millisecond
      timeouts += longTimeout
      timeouts += shortTimeout
      timeouts += mediumTimeout

      sorted <- cat timeouts | sort | collect as List of Millisecond
      stdout.println(`Sorted timeouts: ${sorted}`)

      // === STRING AND ISSET ===

      msStr <- $shortTimeout
      stdout.println(`Timeout as string: ${msStr}`)
      require shortTimeout?

      unsetMs <- Millisecond()
      require ~unsetMs?

      // === COPY OPERATOR ===

      backup <- 0ms
      backup :=: shortTimeout
      stdout.println(`Copied timeout: ${backup}`)

left.toMillis() < right.toMillis()

left < right