Why Untyped Constants in Go Can Sneak Bugs into Your Code

Go allows constants to be declared without an explicit type, creating untyped constants whose type is inferred from the literal value. While this can simplify code, it also introduces hidden pitfalls when the inferred type does not match the expected custom type.

What Are Untyped Constants?

An untyped constant is defined without a type, e.g.:

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)
}

Even though B and C are declared without a type, they default to string and can be passed to output which expects type S.

Default Implicit Types

Untyped constants adopt the default type of their literal: integer literals become int, floating‑point literals become float64, and string literals become string. The actual type is revealed when the constant is used in a context that requires a specific type.

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

Representability (Automatic Type Matching)

If an untyped constant’s value is a valid value for a target type T, the constant can be treated as type T. This is called representability. For example:

const delta = 1 // untyped int
var num int64
num += delta   // delta is automatically treated as int64

The compiler silently converts delta to int64 because the value 1 fits in an int64.

Convenience of Untyped Constants

They reduce the need for explicit casts in complex arithmetic expressions, making code shorter and clearer, especially in data‑analysis or image‑processing calculations.

Pitfalls of Untyped Constants

When simulating enums, forgetting to give each constant an explicit type can cause unexpected behavior:

type ConfigType string

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

Calling a method on CONFIG_JSON fails because the compiler treats it as an untyped string without the Name method:

fmt.Println(CONFIG_XML.Name()) // works
fmt.Println(CONFIG_JSON.Name()) // compile error: untyped string has no field or method Name

Similarly, passing an untyped constant where a custom type is expected can silently accept wrong values, leading to runtime logic errors.

Recommendations

Explicitly specify the type for all constants, especially when they belong to a custom type.

Use tools like stringer to generate robust enum implementations.

Conclusion

Untyped constants automatically adapt to matching types, which can be convenient but also introduces subtle bugs if not handled carefully.