What does a specific EK9 error code mean?

  ek9 -h E50001

  E01010: A reference is missing its module qualifier ('::')
  E01020: The EK9 core module names (org.ek9.lang, org.ek9.math) are reserved
  E01030: A name matches an existing symbol of a different kind in scope
  E01072: 'return' does not exist in EK9

  E02010: A property with this name already exists in the type hierarchy
  E02030: Two or more methods have the same signature

  E04010: A constraint applied to a type that cannot be constrained
  E04020: A string interpolation value cannot be converted to a String

  E05020: Circular type hierarchy detected
  E05030: Type is not open for extension (closed by default)
  E05120: Method or operator must use the override keyword (it overrides a parent's)

  E06260: A 'defines package' property has a value of the wrong kind
  E06280: Too many arguments
  E06290: Too few arguments
  E06330: Incompatible type arguments for a generic type

  E07500: Operator must be pure but is not declared pure
  E07510: Operator cannot be pure (mutation operators)
  E07520: Must return Boolean
  E07550: Must return Integer
  E07570: Must return String
  E07580: Must return JSON
  E07620: The type has no such operator

  E08020: Variable used before it is initialised
  E08030: Optional, Result or Iterator accessed without checking it first
  E08050: Return variable not initialised on all paths
  E08055: Return initialised before a require (declare 'as Type?', assign after the require)
  E08190: Circular dependency injection detected

  E11010: Cyclomatic complexity exceeds the threshold
  E11031: Non-descriptive variable name
  E11032: Variable name shadows a built-in operator keyword
  E11040: A component has too many injected fields

  E50001: Variable or identifier not resolved
  E50030: Incompatible types (one type used where a different one is expected)
  E50060: No method matches that name and those parameter types

defines module qa.debugging.errorcodelookup

  defines class

    Account
      name <- String()
      balance <- Float()

      Account()
        ->
          accountName as String
          initialBalance as Float
        require accountName?
        require initialBalance?
        require initialBalance >= 0.0
        this.name :=: accountName
        this.balance :=: initialBalance

      deposit()
        -> amount as Float
        require amount?
        require amount > 0.0
        balance += amount

      getBalance() as pure
        <- rtn as Float: balance

      operator $ as pure
        <- rtn as String: `Account(${name}, ${balance})`

      //The sameness is the account's identity (its name); == and <> are generated from it
      operator <=> as pure
        -> other as Account
        <- rtn as Integer: name <=> other.name

      operator #? as pure
        <- rtn as Integer: #? name

      override operator ? as pure
        <- rtn as Boolean: name? and balance?

  defines program

    ErrorCodeDemo()
      stdout <- Stdout()

      // Correctly constructed class with operators
      acc <- Account("Alice", 100.0)
      stdout.println(`Account: ${acc}`)

      acc.deposit(50.0)
      stdout.println(`After deposit: ${acc}`)
      stdout.println(`Balance: ${acc.getBalance()}`)

      // Correct comparison usage
      acc2 <- Account("Bob", 200.0)
      stdout.println(`Equal: ${acc == acc2}`)
      stdout.println(`Compare: ${acc <=> acc2}`)

acc.withdraw(50.0)

acc.deposit(50.0)

balance <- acc.getBalance()

stdout.println(`Balance: ${acc.getBalance()}`)