How do I migrate complex control flow from Java or Python to EK9?

  results <- cat items | head 3 | collect as List of String

  valid <- cat items | filter by isNonEmpty | collect as List of String

  if data <- fetch()
    process(data)

  category <- categorise(amount)
  label <- describe(category)

  switch code
    case 1, 2, 3
      result: "low"

#!ek9
defines module qa.flow.philosophy.migration

  defines function

    isNonEmpty() as pure
      -> item as String
      <- nonEmpty as Boolean: length item > 0

    isExpensive() as pure
      -> item as String
      <- expensive <- false
      minExpensiveLength <- 6
      expensive: length item > minExpensiveLength

    categorise() as pure
      -> amount as Integer
      <- category as String: "medium"
      highThreshold <- 100
      lowThreshold <- 10
      if amount >= highThreshold
        category: "high"
      else if amount < lowThreshold
        category: "low"

    describe() as pure
      -> category as String
      <- label as String: "standard item"
      switch category
        case "high"
          label: "premium item"
        case "low"
          label: "budget item"
        default
          label: "standard item"

    findByName()
      ->
        target as String
        items as List of String
      <- found as String: String()
      for item in items
        if item == target
          found: item

  defines program

    MigrationDemo()
      stdout <- Stdout()

      items <- ["", "apple", "banana", "", "cherry", "date", "elderberry", "fig", "grape"]

      // === RULE 1: BREAK -> HEAD ===

      firstThree <- cat items | filter by isNonEmpty | head 3 | collect as List of String
      stdout.println(`First 3 non-empty: ${firstThree}`)

      // === RULE 2: CONTINUE -> FILTER ===

      nonEmpty <- cat items | filter by isNonEmpty | collect as List of String
      stdout.println(`Non-empty items: ${nonEmpty}`)

      // === RULE 3: EARLY RETURN -> GUARD ===

      names <- ["Alice", "Bob", "Charlie"]

      if found <- findByName("Bob", names)
        stdout.println(`Found: ${found}`)

      if found <- findByName("Dave", names)
        stdout.println(`Found: ${found}`)
      else
        stdout.println("Dave not found")

      // === RULE 4: MULTIPLE RETURNS -> DECOMPOSITION ===

      amounts <- [5, 50, 150]
      for amount in amounts
        category <- categorise(amount)
        label <- describe(category)
        stdout.println(`Amount ${amount}: ${label}`)

      // === RULE 5: FALLTHROUGH -> COMMA CASES ===

      codes <- [1, 2, 3, 4, 5]
      for code in codes
        level <- String()
        switch code
          case 1, 2, 3
            level: "basic"
          case 4, 5
            level: "advanced"
          default
            level: "unknown"
        stdout.println(`Code ${code}: ${level}`)

      // === COMBINED: THE MENTAL MODEL SHIFT ===
      // "I want the first 2 expensive items" (not "loop, check, count, break")

      expensive <- cat items | filter by isExpensive | head 2 | collect as List of String
      stdout.println(`First 2 expensive: ${expensive}`)

firstThree <- List() of String
      for item in items
        if isNonEmpty(item)
          firstThree += item
          if length firstThree >= 3
            break

firstThree <- cat items | filter by isNonEmpty | head 3 | collect as List of String

nonEmpty <- List() of String
      for item in items
        if not isNonEmpty(item)
          continue
        nonEmpty += item

nonEmpty <- cat items | filter by isNonEmpty | collect as List of String

<- found as String: String()
      return found

<- found as String: String()

items <- new List("", "apple", "banana", "", "cherry", "date", "elderberry", "fig", "grape")

items <- ["", "apple", "banana", "", "cherry", "date", "elderberry", "fig", "grape"]