How can I compare an enum directly to a string in EK9?

← Enumerations · Ref: Q221

EK9 enumerations support 7 string-parameter comparison operators: ==, <>, <, >, <=, >=, and <=>. You can also construct an enum from a string safely.

DIRECT STRING COMPARISON

Compare any enum variable directly to a string literal: season == "Spring" returns true if the enum holds Spring. No .name(), no .toString(), no conversion needed.

ALL SEVEN OPERATORS

All comparison operators work with strings: ==, <>, <, >, <=, >=, <=>. Ordering follows declaration order, just like enum-vs-enum comparison.

SAFE STRING CONSTRUCTION

Season("Autumn") returns a set enum if the string matches a declared value. Season("Monsoon") returns an unset enum, not an exception.

GUARD EXPRESSION PATTERN

Use guard expressions for the cleanest pattern: 'if parsed <- Season("Summer")' only enters the block when the enum is set. Combines construction and checking in one line.

NO EXCEPTIONS

In Java, valueOf("bad") throws IllegalArgumentException. In Python, Enum["bad"] raises KeyError. In EK9, you simply get unset. No try-catch needed, just use a guard expression.

See Q219 for all auto-generated operators. See Q222 for unset propagation. See Q99 for basic enumeration.

Example

defines module qa.enums.stringcompare

  defines type

    Season
      Spring
      Summer
      Autumn
      Winter

  defines program

    EnumStringCompareDemo()
      stdout <- Stdout()

      season <- Season.Spring

      // === DIRECT STRING COMPARISON ===

      springName <- "Spring"
      stdout.println(`Equals Spring: ${season == springName}`)
      stdout.println(`Not Winter: ${season <> "Winter"}`)

      // === ALL SEVEN STRING COMPARISON OPERATORS ===

      stdout.println(`Less than Summer: ${season < "Summer"}`)
      stdout.println(`Greater than Autumn: ${season > "Autumn"}`)
      stdout.println(`Leq Spring: ${season <= springName}`)
      stdout.println(`Geq Spring: ${season >= springName}`)
      stdout.println(`Compare to Winter: ${season <=> "Winter"}`)

      // === SAFE STRING CONSTRUCTION ===

      valid <- Season("Autumn")
      stdout.println(`Valid: ${valid}, isSet: ${valid?}`)

      invalid <- Season("Monsoon")
      stdout.println(`Invalid isSet: ${invalid?}`)

      // === GUARD EXPRESSION WITH STRING CONSTRUCTION ===

      if parsed <- Season("Summer")
        stdout.println(`Parsed: ${parsed}`)

      if missing <- Season("Rainy")
        stdout.println("This will not print")

Common mistakes

E50060 — EK9 enumerations do not have a 'name()' method like Java enums. Use the == operator directly to compare an enum to a string. All seven comparison operators work with String arguments natively. See ek9 -h E50060 for details.

Incorrect:

season.name() == springName

Correct:

season == springName

Coming from another language?

Java: valueOf() throws IllegalArgumentException for invalid strings, name() and toString() for conversion, no direct string comparison operators. Python: Enum["name"] raises KeyError, must wrap in try/except. Rust: from_str requires implementing or deriving FromStr trait, returns Result. Go: manual string matching with switch or map lookup. C#: Enum.Parse() throws ArgumentException, Enum.TryParse() exists but returns bool. Kotlin: valueOf() throws IllegalArgumentException, entries.find{} for safe lookup. EK9: direct == comparison, safe string construction returns unset not exception.

Keywords: migrate, exception, compare, name, direct, comparison, match, convert, enum, string, enumeration, safe