What is the Void type in EK9?

← Advanced Type System · Ref: Q256

Void represents the concept of no return value in EK9. It is the implicit return type when a function or method has no return declaration (no <- line). You cannot instantiate Void or assign the result of a Void function to a variable (E10010).

IMPLICIT VOID

When a function or method omits the return declaration, its return type is Void:

  greet()
    -> name as String
    stdout.println(name)

This function returns Void because there is no <- declaration. You cannot assign its result to a variable.

FUNCTIONS WITH RETURN VALUES

A function with a <- declaration has an explicit return type:

  doubled()
    -> n as Integer
    <- rtn as Integer: n * 2

This function returns Integer, not Void.

VOID VS UNSET

These are fundamentally different concepts:

  Void: the concept of a value does not apply at all. The function produces no result.
  Unset: an object exists but has no meaningful value yet. Integer() is an unset Integer.

A Void function cannot produce a result. An unset variable can later receive a value.

VOID RESTRICTIONS

- Cannot instantiate: v <- Void() is rejected with E10010
- Cannot assign result: result <- voidFunction() is rejected with E10010
- Void is only ever the implicit return type of a function or method. Do not declare variables, parameters or type arguments of Void: the compiler does not reject all of those yet, and they do not produce working programs.

Void's isSet always returns false because there is no value to be set.

WHY VOID EXISTS

Void gives the type system a way to represent the absence of a return type. Without Void, the compiler would need special-case handling for functions that return nothing. With Void as a type, the type system is uniform: every function has a return type, and Void is the type that means no result.

See Q29 for the unset concept and tri-state semantics. See Q49 for defining functions. See Q50 for function return values.

Example

defines module qa.advancedtypes.voidtype

  defines function

    <?-
      A function that returns nothing (Void).
      No <- declaration means Void return type.
    -?>
    greet()
      -> name as String
      stdout <- Stdout()
      stdout.println(`Hello, ${name}!`)

    <?-
      A function with an explicit return value.
      The <- declaration specifies the return type.
    -?>
    doubled() as pure
      -> n as Integer
      <- rtn as Integer: n * 2

    <?-
      A pure function that formats a greeting.
    -?>
    formatGreeting() as pure
      -> name as String
      <- rtn as String: `Welcome, ${name}`

  defines program

    VoidTypeDemo()
      stdout <- Stdout()

      // Void function: just performs an action, no result
      greet("Steve")

      // Non-void function: returns a value
      result <- doubled(21)
      stdout.println(`Doubled: ${result}`)

      // Can use return value in expressions
      greeting <- formatGreeting("Alice")
      stdout.println(greeting)

      // The following would NOT compile:
      // badResult <- greet("Bob")
      // Error: cannot assign Void result to a variable

Common mistakes

E50060 — Stdout does not have a display() method. The correct method is println(). Calling a non-existent method triggers E50060 — method not resolved. See ek9 -h E50060 for details.

Incorrect:

stdout.display(`Doubled: ${result}`)

Correct:

stdout.println(`Doubled: ${result}`)

Coming from another language?

Java: void keyword (lowercase, not a type), Void class exists but rarely used directly. C#: void keyword, similar to Java. Python: functions without return implicitly return None (which IS a value). Rust: unit type () serves as void, IS a real type with one value. Go: functions without return type return nothing, no void keyword. Kotlin: Unit type (like Rust's unit), is a real singleton value. Swift: Void is a typealias for empty tuple (). EK9: Void is the implicit return type for functions without <- declaration, cannot be instantiated or assigned (E10010), distinct from unset.

Keywords: restriction, type, type-system, ok, function, implicit, void, advanced, error, unset, guard, declare, method, result, return