How does the Millisecond type work in EK9 and how does it relate to Duration?

defines module qa.millisecond

  defines program
    MillisecondDemo()
      stdout <- Stdout()

      // === MILLISECOND LITERALS ===

      // Simple ms suffix on integers
      shortTimeout <- 100ms
      halfSecond <- 500ms
      oneSecond <- 1000ms
      stdout.println(`Short: ${shortTimeout}`)
      stdout.println(`Half second: ${halfSecond}`)
      stdout.println(`One second: ${oneSecond}`)

      // Negative milliseconds
      negMs <- -250ms
      stdout.println(`Negative: ${negMs}`)

      // Unset
      unsetMs <- Millisecond()
      require ~unsetMs?
      stdout.println(`Unset isSet: ${unsetMs?}`)

      // === ARITHMETIC ===

      // Add milliseconds together
      combined <- 100ms + 50ms
      stdout.println(`100ms + 50ms = ${combined}`)

      // Multiply by Float or Integer (scaling)
      scaled <- 100ms * 3.5
      stdout.println(`100ms * 3.5 = ${scaled}`)

      scaledInt <- 100ms * 5
      stdout.println(`100ms * 5 = ${scaledInt}`)

      // Divide by Integer or Float
      halved <- 1000ms / 2
      stdout.println(`1000ms / 2 = ${halved}`)

      // Divide Millisecond by Millisecond gives Float ratio
      ratio <- 750ms / 250ms
      stdout.println(`750ms / 250ms = ${ratio}`)

      // Increment and decrement
      ticker <- 100ms
      ticker++
      stdout.println(`After ++: ${ticker}`)
      ticker--
      stdout.println(`After --: ${ticker}`)

      // Negation
      pos <- 500ms
      neg <- -pos
      stdout.println(`Negated: ${neg}`)

      // Absolute value
      absVal <- abs neg
      require absVal == pos
      stdout.println(`abs: ${absVal}`)

      // === CONVERSION TO DURATION ===

      // duration() method converts Millisecond to Duration
      // Values >= 500ms round up to the nearest second
      fiveSeconds <- 5000ms
      asDuration <- fiveSeconds.duration()
      stdout.println(`5000ms as Duration: ${asDuration}`)

      // 501ms rounds up to 1 second
      nearlyASecond <- 501ms
      stdout.println(`501ms as Duration: ${nearlyASecond.duration()}`)

      // Negative milliseconds
      negDuration <- -501ms
      stdout.println(`-501ms as Duration: ${negDuration.duration()}`)

      // #^ promote operator also converts to Duration
      promoted <- #^ 3000ms
      stdout.println(`Promoted to Duration: ${promoted}`)

      // === CONSTRUCT FROM DURATION ===

      // Create Millisecond from a Duration literal
      twoWeeks <- Millisecond(P2W)
      stdout.println(`P2W as Millisecond: ${twoWeeks}`)

      fiveMinutes <- Millisecond(PT5M)
      stdout.println(`PT5M as Millisecond: ${fiveMinutes}`)

      // === ADD DURATION TO MILLISECOND ===

      base <- 5400ms
      withDuration <- base + PT1S
      stdout.println(`5400ms + PT1S = ${withDuration}`)

      // === PERFORMANCE TIMING ===

      starting <- SystemClock().millisecond()
      stdout.println("Do some work")
      ending <- SystemClock().millisecond()
      elapsed <- ending - starting
      stdout.println(`Elapsed: ${elapsed}`)

      // === COMPARISON ===

      require 100ms < 500ms
      require 500ms > 100ms
      require 100ms <> 500ms
      require 100ms == 100ms
      require 100ms <= 100ms
      require 100ms >= 100ms

      shortDelay <- 100ms
      ordering <- shortDelay <=> 500ms
      stdout.println(`100ms <=> 500ms: ${ordering}`)

      // === UNSET PROPAGATION ===

      unsetResult <- unsetMs + 100ms
      require ~unsetResult?
      stdout.println(`Unset + 100ms isSet: ${unsetResult?}`)

      // === HASHCODE ===

      hash <- #? 500ms
      stdout.println(`Hash of 500ms: ${hash}`)

fiveSeconds.toSeconds()

fiveSeconds.duration()