Show all four coalescing comparison operators on Integer values.

  minOf() as pure
    -> left as Integer, right as Integer
    <- rtn as Integer: left <? right     //lesser
  maxOf() as pure
    -> left as Integer, right as Integer
    <- rtn as Integer: left >? right     //greater
  minOrEqual() as pure
    -> left as Integer, right as Integer
    <- rtn as Integer: left <=? right    //lesser-or-equal
  maxOrEqual() as pure
    -> left as Integer, right as Integer
    <- rtn as Integer: left >=? right    //greater-or-equal

defines module qa.operators.allcoalescing

  defines function

    // <? — returns the LESSER of two values
    minOf() as pure
      ->
        left as Integer
        right as Integer
      <- rtn as Integer: left <? right

    // >? — returns the GREATER of two values
    maxOf() as pure
      ->
        left as Integer
        right as Integer
      <- rtn as Integer: left >? right

    // <=? — returns the lesser-or-equal of two values
    minOrEqual() as pure
      ->
        left as Integer
        right as Integer
      <- rtn as Integer: left <=? right

    // >=? — returns the greater-or-equal of two values
    maxOrEqual() as pure
      ->
        left as Integer
        right as Integer
      <- rtn as Integer: left >=? right

  defines program

    AllCoalescingOperatorsDemo()
      stdout <- Stdout()

      // === ALL FOUR OPERATORS WITH BOTH VALUES SET ===

      scoreA <- 78
      scoreB <- 92

      minResult <- minOf(scoreA, scoreB)
      stdout.println(`<? minimum: ${minResult}`)

      maxResult <- maxOf(scoreA, scoreB)
      stdout.println(`>? maximum: ${maxResult}`)

      lessOrEqualResult <- minOrEqual(scoreA, scoreB)
      stdout.println(`<=? lesser-or-equal: ${lessOrEqualResult}`)

      greaterOrEqualResult <- maxOrEqual(scoreA, scoreB)
      stdout.println(`>=? greater-or-equal: ${greaterOrEqualResult}`)

      // === WITH EQUAL VALUES ===

      valueA <- 50
      valueB <- 50

      equalMin <- minOf(valueA, valueB)
      stdout.println(`<? with equal values: ${equalMin}`)

      equalMax <- maxOf(valueA, valueB)
      stdout.println(`>? with equal values: ${equalMax}`)

      // === WITH ONE UNSET — all return the set value ===

      activeReading <- 65
      offlineReading <- Integer()

      minUnset <- minOf(activeReading, offlineReading)
      stdout.println(`<? one unset: ${minUnset}`)

      maxUnset <- maxOf(activeReading, offlineReading)
      stdout.println(`>? one unset: ${maxUnset}`)

      lessEqualWhenUnset <- minOrEqual(activeReading, offlineReading)
      stdout.println(`<=? one unset: ${lessEqualWhenUnset}`)

      greaterEqualWhenUnset <- maxOrEqual(activeReading, offlineReading)
      stdout.println(`>=? one unset: ${greaterEqualWhenUnset}`)

      // === WITH BOTH UNSET — all return unset ===

      missingA <- Integer()
      missingB <- Integer()

      noneMin <- minOf(missingA, missingB)
      if noneMin?
        stdout.println(`Unexpected: ${noneMin}`)
      else
        stdout.println("<? both unset: result is unset")