Why does AI confuse declarations and assignments in EK9?

← What AI Gets Wrong About EK9 · Ref: Q276

AI models generate 'x = 5', 'let x = 5', 'var x = 5', or 'val x = 5' in EK9. None of these are valid EK9 declarations. AI conflates two distinct concepts: creating a new variable (declaration) and changing an existing variable (assignment).

THE AI MISTAKE

AI does not understand EK9's distinction between declaration and assignment. It imports syntax from JavaScript (let/const), Kotlin (val/var), Rust (let), or Java (type name = value).

EK9 DECLARATIONS

Create a new variable with '<-' (type inferred) or explicit type with ':' initialiser:

  name <- "hello"
  age <- 42
  score as Float: 9.5
  greeting as String: "hi"

The '<-' operator creates AND initialises. The 'as Type:' form declares with explicit type.

EK9 ASSIGNMENTS

Assign to an EXISTING variable with ':', ':=', or '=':

  name: "world"
  name := "world"
  name = "world"

All three have IDENTICAL semantics. The choice is stylistic:

  ':' is concise, natural in loop bodies, switch branches, if/else blocks
  ':=' is stronger, highlights significant or deliberate assignments
  '=' is also valid, same semantics as the other two

GUARDED ASSIGNMENT

The ':=?' operator has DIFFERENT semantics from the other three. It only assigns if the variable is currently UNSET:

  config <- String()
  config :=? "default"
  config :=? "other"

After this, config is "default". The second ':=?' does nothing because config is already set.

THE COMPILER ENFORCES THE DISTINCTION

Using '<-' on an existing variable is an error. Using ':' or ':=' on a non-existent variable is an error. The compiler knows whether you are declaring or assigning.

See Q24 for variable declaration. See Q29 for guarded assignment. See Q168 for fallback values. See Q243 for coalescing operators. See Q281 for verifying AI code.

Example

defines module qa.ai.mistakes.assignment

  defines program

    AssignmentDemo()
      stdout <- Stdout()

      // === DECLARATIONS WITH <- ===

      name <- "Alice"
      age <- 30
      active <- true

      stdout.println(`Declared: ${name}, ${age}, ${active}`)

      // === EXPLICIT TYPE DECLARATIONS ===

      greeting as String: "Hello"
      limit as Integer: 100

      stdout.println(`Typed: ${greeting}, ${limit}`)

      // === ASSIGNMENTS (all three identical) ===

      name: "Bob"
      stdout.println(`After ':' assignment: ${name}`)

      name := "Charlie"
      stdout.println(`After ':=' assignment: ${name}`)

      name = "Diana"
      stdout.println(`After '=' assignment: ${name}`)

      // === GUARDED ASSIGNMENT :=? ===

      config <- String()
      stdout.println(`Before guard: config is set? ${config?}`)

      config :=? "default"
      stdout.println(`After first guard: ${config}`)

      config :=? "other"
      stdout.println(`After second guard: ${config}`)

      // === STYLISTIC CHOICE IN CONTEXT ===

      total <- 0
      for num in [1, 2, 3, 4, 5]
        total: total + num
      stdout.println(`Loop total with ':': ${total}`)

      strategy <- "none"
      strategy := "aggressive"
      stdout.println(`Strategy with ':=': ${strategy}`)

Common mistakes

E50001 — Using '=' attempts to assign to an existing variable, but 'name' was never declared. In EK9, '<-' creates a new variable (declaration), while '=', ':=', and ':' assign to an EXISTING variable. AI trained on Python uses '=' for both, but EK9 enforces the distinction. See ek9 -h E50001 for details.

Incorrect:

name = "Alice"

Correct:

name <- "Alice"

Coming from another language?

Java: 'Type name = value' for declaration, 'name = value' for assignment, same '=' symbol for both. JavaScript: 'let x = 5', 'const x = 5', 'x = 5'. Kotlin: 'val x = 5' (immutable), 'var x = 5' (mutable). Rust: 'let x = 5', 'let mut x = 5'. Python: 'x = 5' for both declaration and assignment. Go: ':=' for short declaration, '=' for assignment. EK9: '<-' for declaration (type inferred), 'as Type:' for explicit type, ':', ':=', '=' for assignment (all identical), ':=?' for guarded assignment (different semantics).

Keywords: equals, hallucination, operator, infer, syntax, let, var, assignment, variable, pitfall, common-error, declare, migrate, wrong, declaration, ai, mistake