How do I join or concatenate strings in EK9?

← Common String Operations · Ref: Q174

EK9 provides several ways to combine strings: backtick interpolation (preferred), the + operator (for simple cases), += append, and stream collect.

BACKTICK INTERPOLATION (preferred)
Embed expressions in backtick strings:

  stdout.println(`Welcome ${name}, you are ${age} years old`)

Any expression inside ${...} is evaluated and converted to string. Interpolation compiles to a single allocation via a bespoke STRING_INTERPOLATION IR instruction. Always prefer this for 3+ parts.

PLUS OPERATOR (2-part only)
Concatenate two strings with +:

  full <- first + second

Creates a new string from two parts. Chains of 3 or more parts (e.g. a + b + c) trigger compiler error E11068 because each + creates an intermediate String object. Use interpolation instead:

  BAD:  result <- first + " " + second
  GOOD: result <- `${first} ${second}`

APPEND (+=)

Mutate a string variable by appending:

  greeting <- "Hello"
  greeting += " World"

STREAM COLLECT

Join a list of strings via stream pipeline:

  combined <- cat ["Hello", " ", "World"] | collect as String

See Q37 for string basics. See Q43 for escape sequences in interpolation. See Q309 for the E11068 compiler error details.

Example

#!ek9
defines module qa.stringops.concat

  defines program
    StringConcatDemo()
      stdout <- Stdout()

      first <- "Hello"
      second <- "World"

      // === BACKTICK INTERPOLATION (preferred) ===

      // Interpolation compiles to a single allocation
      combined <- `${first} ${second}`
      stdout.println(`Interpolated: ${combined}`)

      name <- "Steve"
      age <- 30
      stdout.println(`Name: ${name}, Age: ${age}`)

      // Expressions inside interpolation
      stdout.println(`Upper: ${name.upperCase()}`)
      stdout.println(`Length: ${length name}`)

      // === PLUS OPERATOR (2-part only) ===

      // Two-part concatenation is allowed
      twoPartConcat <- first + second
      stdout.println(`Two-part: ${twoPartConcat}`)

      // Three or more parts would trigger E11068:
      //   result <- first + " " + second   // Error!
      // Use interpolation instead:
      //   result <- `${first} ${second}`    // Correct

      // === APPEND (+=) ===

      greeting <- "Hello"
      greeting += " "
      greeting += "World"
      stdout.println(`Appended: ${greeting}`)

      // === STREAM COLLECT ===

      parts <- ["Hello", " ", "World", "!"]
      joined <- cat parts | collect as String
      stdout.println(`Stream joined: ${joined}`)

      // === BUILDING FROM MULTIPLE VALUES ===

      host <- "localhost"
      port <- 8080
      url <- `http://${host}:${port}`
      stdout.println(`URL: ${url}`)

      // Interpolation is cleaner for mixed types
      stdout.println(`URL: http://${host}:${port}`)

Common mistakes

E11068 — Concatenating 3 or more string parts with + triggers E11068. Use backtick interpolation instead. See ek9 -h E11068 for details.

Incorrect:

combined <- first + " " + second

Correct:

combined <- `${first} ${second}`
Other ways to ask this
  • How do I combine strings together in EK9?
  • What is the EK9 equivalent of string concatenation?
  • How do I embed expressions inside EK9 strings?

Coming from another language?

Java: + operator, String.concat(), StringBuilder, String.format(). Python: + operator, f-strings, .join(). Rust: format!() macro, + operator, .push_str(). Go: + operator, fmt.Sprintf(). JavaScript: + operator, template literals. Kotlin: + operator, string templates. EK9: backtick interpolation (preferred), + operator (2-part only, 3+ is E11068), += append, stream collect.

Keywords: E11068, append, combine, concat, concatenate, interpolation, join, merge, plus, string, text