How do I declare a variable in EK9?

  name <- "Steve"           Inferred as String
  count <- 42                Inferred as Integer

  name as String: "Steve"

  name <- "Steve"       Declaration (new variable)
  name := "John"        Reassignment (existing variable)
  name :=? "Default"    Guarded: only if currently unset

  greeting as String: "Hello"    Private by default

  formatName() as pure
    -> first as String
    <- result as String: first

  result <- formatName(first: "Steve", last: "Limb")

  multiplier <- (factor: count) is abstractOp as pure function
    result :=? operand * factor

  public/protected/private   Access (default: package-private)
  pure         No side effects, enforced on overrides
  abstract     Must be overridden
  override     Required when replacing parent method
  open         Allows extension (closed by default)
  default      Auto-generates operators
  dispatcher   Multi-method dispatch by argument type
  sanitized    Input sanitization at call site

defines module qa.variables.declarations

  defines function

    formatName() as pure
      ->
        first as String
        last as String
      <- result as String: `${first} ${last}`

    abstractOp() as pure abstract
      -> operand as Integer
      <- result as Integer?

  defines class

    Greeter
      greeting as String: "Hello"

      Greeter()
        -> g as String
        greeting :=: g

      greet()
        -> name as String
        <- message as String: `${greeting}, ${name}`

      default operator ?

  defines program
    Declarations()
      stdout <- Stdout()

      // Type inference - idiomatic for local variables
      name <- "Steve"
      count <- 42

      // Explicit type - useful when declaring a base type
      label as String: "Count"

      // Reassignment
      name := "John"

      // Using the explicitly typed variable
      stdout.println(`${label}: ${count}`)

      // Named parameters at call site
      full <- formatName(first: name, last: "Limb")
      stdout.println(full)

      // Dynamic function with named captures
      multiplier <- (factor: count) is abstractOp as pure function
        result :=? operand * factor

      stdout.println($multiplier(3))

      greeter <- Greeter("Welcome")
      stdout.println(greeter.greet(name))

greeting as String

greeting as String: "Hello"

operator ?

default operator ?

full <- formatNam(first: name, last: "Limb")

full <- formatName(first: name, last: "Limb")