How do I work with colours?

  #FF0000         Pure red (6-digit RGB)
  #FF186276       With alpha (8-digit ARGB)

  .RGB() returns '#RRGGBB', .RGBA() returns '#RRGGBBAA', .ARGB() returns '#AARRGGBB'.

  purple <- #FF0000 + #0000FF

  .bits() extracts 32-bit ARGB value. Colour(bitsValue) constructs from Bits.

defines module qa.colour

  defines program
    ColourDemo()
      stdout <- Stdout()

      // === COLOUR LITERALS ===

      // Hex literal with alpha channel: #AARRGGBB (ARGB format)
      opaqueBlue <- #FF186276
      stdout.println(`Opaque blue: ${opaqueBlue}`)

      // Hex literal without alpha: #RRGGBB (RGB format)
      pureRed <- #FF0000
      pureGreen <- #00FF00
      pureBlue <- #0000FF
      stdout.println(`Red: ${pureRed}, Green: ${pureGreen}, Blue: ${pureBlue}`)

      // Unset colour
      unsetColour <- Colour()
      require ~unsetColour?

      // === OUTPUT FORMATS ===

      // Three different hex string formats
      stdout.println(`RGB: ${opaqueBlue.RGB()}`)
      stdout.println(`RGBA: ${opaqueBlue.RGBA()}`)
      stdout.println(`ARGB: ${opaqueBlue.ARGB()}`)

      // === HSL ACCESSORS ===

      // Hue (0-360), Saturation (0-100%), Lightness (0-100%)
      stdout.println(`Hue: ${opaqueBlue.hue()}`)
      stdout.println(`Saturation: ${opaqueBlue.saturation()}`)
      stdout.println(`Lightness: ${opaqueBlue.lightness()}`)

      // === HSL MANIPULATION ===

      // Each with* method returns a NEW colour (immutable)
      lighterBlue <- opaqueBlue.withLightness(80)
      stdout.println(`Lighter: ${lighterBlue}`)

      moreSaturated <- lighterBlue.withSaturation(90)
      stdout.println(`More saturated: ${moreSaturated}`)

      shiftedHue <- opaqueBlue.withHue(200)
      stdout.println(`Shifted hue: ${shiftedHue}`)

      // === ALPHA CHANNEL (TRANSPARENCY) ===

      // withOpaque(percentage) sets opacity: 100=fully opaque, 0=fully transparent
      semiTransparent <- opaqueBlue.withOpaque(50)
      stdout.println(`50% opaque: ${semiTransparent}`)

      mostlyOpaque <- opaqueBlue.withOpaque(80)
      stdout.println(`80% opaque: ${mostlyOpaque}`)

      // === COLOUR ARITHMETIC ===

      // Add colours: blends RGB components (clamped to 0-255)
      purple <- pureRed + pureBlue
      stdout.println(`Red + Blue = Purple: ${purple}`)

      yellow <- pureRed + pureGreen
      stdout.println(`Red + Green = Yellow: ${yellow}`)

      cyan <- pureGreen + pureBlue
      stdout.println(`Green + Blue = Cyan: ${cyan}`)

      // Subtract colours: removes RGB components (clamped to 0)
      backToRed <- purple - pureBlue
      stdout.println(`Purple - Blue = Red: ${backToRed}`)
      require backToRed == pureRed

      backToGreen <- yellow - pureRed
      stdout.println(`Yellow - Red = Green: ${backToGreen}`)
      require backToGreen == pureGreen

      // Subtract specific amounts of a channel
      lessRed <- moreSaturated - #9A0000
      stdout.println(`Less red: ${lessRed}`)

      moreBlue <- lessRed + #00001D
      stdout.println(`More blue: ${moreBlue}`)

      // === BITS INTEROP ===

      // Convert Colour to Bits and back
      colourBits <- opaqueBlue.bits()
      stdout.println(`As bits: ${colourBits}`)

      fromBits <- Colour(colourBits)
      require fromBits == opaqueBlue

      // Build colour from raw bit patterns
      redBits <- 0b11111111111111110000000000000000
      redFromBits <- Colour(redBits)
      stdout.println(`Red from bits: ${redFromBits}`)

      // === PROGRAMMATIC LIGHTENING ===

      // Calculate a percentage lighter
      currentLightness <- opaqueBlue.lightness()
      proposedLightness <- currentLightness * 1.9
      clampedLightness <- proposedLightness <? 100
      percentLighter <- opaqueBlue.withLightness(clampedLightness)
      stdout.println(`90% lighter: ${percentLighter}`)

      // === COMPARISON ===

      require pureRed <> pureBlue
      require #FF0000 == #FF0000
      stdout.println(`Red == Red: ${pureRed == #FF0000}`)

opaqueBlue.setLightness(80)

opaqueBlue.withLightness(80)