The Hidden Privilege of Go’s Type System: Untyped Constants

In Go you use const without declaring a type; untyped constants are a hidden privilege of the type system.

1. Identity crisis for beginners

Variables require explicit types, e.g.

var age int = 18 // must declare int
var price float64 = 9.9 // must declare float64

Writing var a = 1 + 2i gives a warning; the compiler infers complex128, so it is still a typed variable.

Constants can be declared without a type:

const magic = 1 + 2i // no type
const bigNum = 1 << 100 // huge number

These are untyped constants; they have no concrete type like int, float64, or complex128. The compiler treats them as pure numeric concepts.

2. Precision superpower: no overflow

Example computing 2ⁱ⁰⁰.

// Variable version overflows
var v int = 1 << 100 // compile error: constant overflows int

// Constant version works
const c = 1 << 100

This is “delayed typing”.

Analogy: check vs cash

Variable (Typed) : like cash in a fixed‑size wallet; overflow if too much.

Untyped constant : like an unlimited check; only when assigned to a variable does the type check occur.

The compiler maintains a high‑precision arithmetic engine that keeps unlimited precision until the value is assigned to a concrete type.

3. Chameleon: implicit conversion privilege

Untyped constants can adapt to context without explicit casts.

const c = 10
var i int = c        // ok, c becomes int
var f float64 = c    // ok, c becomes float64
var b byte = c       // ok if value fits
complexNum := complex(0, c) // c becomes float64 for complex

With variables, implicit conversion is not allowed:

var v = 10 // v inferred as int
var f float64 = v // compile error
var f float64 = float64(v) // ok with explicit cast

Design reasoning: Go is statically typed and dislikes implicit conversion, but for constants it makes a safe compromise because conversion happens at compile time and is guaranteed safe.

4. Why variables must have a type

Constants live at compile time and become immediate values or read‑only data. Variables exist at runtime and need memory layout (size, representation). Without a type the compiler cannot allocate memory or generate instructions.

5. Design philosophy: balancing static safety and flexibility

Maximize compile‑time computation; untyped constants allow complex expressions to be evaluated with high precision before runtime.

Reduce boilerplate; const Pi = 3.14 can be used as float32 or float64 without repeating the type.

Safety boundary; once a constant becomes a variable it must be typed, ensuring predictable performance and memory safety.

A subtle trap

When an untyped constant is used without a target type it defaults to a concrete type (int, float64, bool, string, etc.). Example:

const a = 100 // untyped int
const b = 3.14 // untyped float
var x = a + b // error: mismatched types

Correct usage promotes the constant to the needed type during assignment:

const a = 100
const b = 3.14
var y float64 = a + b // a promoted to float64, result assigned to y

6. Summary: how to leverage this hidden privilege

Prefer const for magic numbers to gain high precision and flexibility.

Use constants for large‑scale calculations, then assign to variables after checking overflow.

Understand default types: untyped constants adopt int, float64, bool, or string when standing alone.

Accept that variables must be typed; this is the foundation of runtime performance.