What built-in types can be constrained in EK9?

  String — constrain as matches /pattern/ or equality
  Integer — constrain as > 0 and < 100
  Float — constrain as > 0.0 and < 1.0
  Character — constrain as >= 'A' and <= 'Z'
  Date — constrain as >= 2024-01-01 and <= 2024-12-31
  Time — constrain as >= 09:00 and <= 17:00
  DateTime — constrain as >= date-time ranges
  Duration — constrain as >= P1D and <= P30D
  Millisecond — constrain as >= 0ms and <= 5000ms
  Dimension — constrain as >= 0m and <= 100m
  Resolution — constrain as >= 300dpi
  Money — constrain as >= 10000#GBP and <= 120000#GBP
  Colour — constrain as #0099CC or #9900CC
  Version — constrain as >= 1.0.0-0
  Path — constrain as equality
  RegEx — constrain as equality
  Enumerations — constrain as "Value1" or "Value2"

  ValidPerson as Person constrain as
    matches /^[a-zA-Z]+ [a-zA-Z]+$/

  Point
    x as Integer: Integer()   //allocated but UNSET - correct
    y as Integer: 0           //always SET - leaves the constrained type unable to be unset

  Boolean — already has only two values
  Bits — has comparison operators but no literal form usable in a constraint
  JSON — dynamic structure, undefined comparison semantics
  Functions — code references, not values
  Traits — cannot be instantiated
  Abstract classes — cannot be instantiated
  Components — singleton services, not value types
  An already-constrained type — constraining is ONE-LEVEL (see Q722)
  Parameterised generics such as 'List of String' (E06132) — a collection is SET when created, so there is no unset state for the constrained type to borrow; and a whole-container predicate like 'contains' is a require condition, not a type invariant (a mutating '+=' would re-validate, so a mutation could break it). Constrain the ELEMENT type instead:
    Tag as String constrain as
      matches /^[a-z]+$/
  then hold 'List of Tag'. That guarantee is stronger - it holds for every element however the list is assembled.

  Index as Integer          //alias, no constraint
  Name as String            //alias, no constraint

defines module qa.advancedtypes.constrainabletypes

  defines type

    // === STRING CONSTRAINT: regex pattern ===
    Name as String constrain as
      matches /^[a-zA-Z -]+$/

    // === INTEGER CONSTRAINT: range ===
    PositiveIndex as Integer constrain as
      > 0 and < 1000

    // === MONEY CONSTRAINT: salary range ===
    Salary as Money constrain as
      >= 10000#GBP and <= 120000#GBP

    // === DATE CONSTRAINT: year range ===
    RecentDate as Date constrain as
      >= 2020-01-01 and <= 2030-12-31

    // === COLOUR CONSTRAINT: specific values ===
    BrandColour as Colour constrain as
      #0099CC or #9900CC

    // === ELEMENT CONSTRAINT: the right tool for "a list of only these values" ===
    // A parameterised generic cannot be a constrained base (E06132). Constrain the ELEMENT
    // and hold a collection of it - the guarantee then holds for every element.
    Tag as String constrain as
      matches /^[a-z]+$/

    // === SIMPLE ALIAS (no constraint) ===
    Index as Integer

  defines program

    ConstrainableTypesDemo()
      stdout <- Stdout()

      // === STRING CONSTRAINT ===
      // Use the fallible 'of' factory for untrusted input: it returns an UNSET value on a
      // constraint failure rather than Panicking (a bare Name("123!@#") would Panic at runtime,
      // and is a compile error E08260 when the bad value is a literal constant).
      if goodName <- Name().of("Alice Smith")
        stdout.println(`Valid name: ${goodName}`)

      badName <- Name().of("123!@#")
      stdout.println(`Invalid name set: ${badName?}`)

      // === INTEGER CONSTRAINT ===
      if goodIndex <- PositiveIndex().of(42)
        stdout.println(`Valid index: ${goodIndex}`)

      badIndex <- PositiveIndex().of(0)
      stdout.println(`Zero index set: ${badIndex?}`)

      // === MONEY CONSTRAINT ===
      if goodSalary <- Salary().of(50000#GBP)
        stdout.println(`Valid salary: ${goodSalary}`)

      badSalary <- Salary().of(5000#GBP)
      stdout.println(`Low salary set: ${badSalary?}`)

      // === DATE CONSTRAINT ===
      if goodDate <- RecentDate().of(2024-06-15)
        stdout.println(`Valid date: ${goodDate}`)

      badDate <- RecentDate().of(2019-01-01)
      stdout.println(`Old date set: ${badDate?}`)

      // === COLOUR CONSTRAINT ===
      if goodColour <- BrandColour().of(#0099CC)
        stdout.println(`Valid colour: ${goodColour}`)

      badColour <- BrandColour().of(#FF0000)
      stdout.println(`Wrong colour set: ${badColour?}`)

      // === ELEMENT CONSTRAINT RATHER THAN A CONSTRAINED COLLECTION ===
      tags <- List() of Tag
      tags += Tag("alpha")
      stdout.println(`Tags: ${tags}, length ${length tags}`)

      rejectedTag <- Tag().of("NOT-LOWER")
      stdout.println(`Rejected tag set: ${rejectedTag?}`)

      // === SIMPLE ALIAS ALWAYS WORKS ===
      idx <- Index(999)
      stdout.println(`Alias index: ${idx}`)

Name().of("Alice Smith").getValue()

Name().of("Alice Smith")

idx <- Index(999).intValue()

idx <- Index(999)