Why Untyped Constants in Go Can Sneak Up on You (and How to Avoid the Pitfalls)

What Are Untyped Constants?

In Go, a constant without an explicit type is called an untyped constant . Although the type is not declared, the constant still has a default type derived from its literal value (e.g., string literals become string, integer literals become int).

Default Implicit Type

package main
import "fmt"

type S string

const (
    A S = "a"
    B = "b"
    C = "c"
)

func output(s S) { fmt.Println(s) }
func main() { output(A); output(B); output(C) }

Here A is explicitly typed as S, while B and C are untyped. The compiler infers their default type as string, allowing them to be passed to output which expects S because the untyped constant can be represented as the target type.

Representability (Type Auto‑Matching)

The Go spec calls this behavior Representability : if an untyped constant’s value is a valid value of a target type T, the constant can be used as type T in that context.

fmt.Println(reflect.TypeOf(any(A))) // main.S
fmt.Println(reflect.TypeOf(any(B))) // string
fmt.Println(reflect.TypeOf(any(C))) // string

Thus B and C are treated as string and can be assigned to variables of type S without an explicit conversion.

Conveniences

Untyped constants let you write concise arithmetic without repetitive casts:

const factor = 2 // untyped, default int
var result int64 = int64(num) * factor / ((a + b + c) / factor)

The compiler automatically matches factor to int64 in the expression.

Pitfalls

When the target type is not inferred, the constant remains untyped, which can lead to subtle bugs, especially when simulating enums.

type ConfigType string

const (
    CONFIG_XML ConfigType = "XML"
    CONFIG_JSON = "JSON" // untyped string
)

func (c ConfigType) Name() string {
    switch c {
    case CONFIG_XML:
        return "XML"
    case CONFIG_JSON:
        return "JSON"
    }
    return "invalid"
}

Calling CONFIG_JSON.Name() fails because CONFIG_JSON is still an untyped string, not a ConfigType. The compiler error is:

CONFIG_JSON.Name undefined (type untyped string has no field or method Name)

Similarly, untyped constants can be passed to functions expecting a custom type, unintentionally mixing unrelated values:

const NET_ERR_MESSAGE = "site is unreachable"

doWithConfigType(CONFIG_JSON) // ok
doWithConfigType(NET_ERR_MESSAGE) // compiles but wrong logical type

These issues arise because the constant’s type is only fixed when the context forces a specific type.

Recommendations

Prefer giving constants an explicit type, especially for custom types used in APIs or enums.

Use code‑generation tools (e.g., stringer) to create robust enum implementations.

Apply defensive programming: validate inputs and avoid relying on implicit type matching for critical logic.

Summary

Untyped constants in Go automatically adapt to a matching target type, which can simplify code but also introduce hard‑to‑detect bugs. Explicitly typing constants and using tooling for enums are effective ways to mitigate these pitfalls.