Making the Invisible Visible: Understanding Go’s Static vs Runtime Types

Picture this scenario. The Golang compiler shouting at you for using a type that it can iterate over. You have checked the type multiple times but it still won’t compile the code for you. Why is that and where are type assertions fitting in?

Here’s a code example of this. You’re working with JSON data in Go, and you encounter something that seems contradictory.

// After JSON unmarshaling some unstructured data

fmt.Printf("Type: %T\n", result["users"])      // Output: []interface {}

// Let's iterate over this array of interfaces

for i, user := range result["users"] { ... }   // Error: cannot range over interface{}

Wait, what? The type is clearly []interface{} – a slice – so why can’t we iterate over it? The answer reveals a fundamental aspect of Go’s type system.

Root of the Problem: Static vs Runtime Types in Go

The key to understanding this lies in recognizing that Go variables have two types:

1. Static Type: What the compiler knows at compile time
2. Runtime Type: What’s actually stored in memory at runtime

Let’s see this in action

package main

import (
"encoding/json"
"fmt"
"reflect"
)

func main() {
   jsonData := `{
       "users": [{"name": "Alice", "social": {"twitter": "@alice"}}]
       }`

   var result map[string]interface{}
   json.Unmarshal([]byte(jsonData), &result)

   // What we get from the map
   usersFromMap := result["users"]

   fmt.Printf("Static type (what compiler sees): interface{}\n")
   fmt.Printf("Runtime type (what's actually stored): %T\n", usersFromMap)
   fmt.Printf("Reflect type: %s\n", reflect.TypeOf(usersFromMap))
}

Output

Static type (what compiler sees): interface{}
Runtime type (what's actually stored): []interface {}
Reflect type: []interface {}

Why the Go Compiler Says “No” ??!

When you declare: var result map[string]interface{}

The compiler knows that result["users"] has the static type interface{}.
Even though the JSON unmarshaler puts a []interface{} value there at runtime, the compiler only sees interface{} at compile time.

usersFromMap := result["users"] // Static type: interface{}

// This fails because the compiler sees interface{}, not []interface{}

for i, user := range usersFromMap { // ❌ Compile error
    fmt.Println(i, user)
}

Understanding the Compiler’s Perspective

I see you’re trying to range over an `interface{}`. But, `interface{}` could be anything – a string, a number, a struct, or yes, even a slice. I can’t generate code to iterate over ‘anything’, so this is a compile error.

Type assertions are your way of saying to the compiler: “Trust me, I know what this really is.”

// Type assertion: interface{} → []interface{}

users, ok := result["users"].([]interface{})

// Now users has:
// - Static type: []interface{}
// - Runtime type: []interface{}

for i, user := range users {           // ✅ Works perfectly!
    fmt.Printf("User %d: %v\n", i, user)
}

Complete Type Assertion Chain in JSON Processing

When working with nested JSON structures, you often need multiple type assertions:

func processUsers(result map[string]interface{}) {
	// 1st assertion: interface{} → []interface{}
	users, ok := result["users"].([]interface{})
	if !ok {
		fmt.Println("Users field is not an array")
		return
	}

	for i, userInterface := range users {
		// 2nd assertion: interface{} → map[string]interface{}
		user, ok := userInterface.(map[string]interface{})
		if !ok {
			fmt.Printf("User %d is not a valid object\n", i)
			continue
		}

		fmt.Printf("Name: %v\n", user["name"])

		// 3rd assertion: interface{} → map[string]interface{}
		if social, ok := user["social"].(map[string]interface{}); ok {
			fmt.Printf("Twitter: %v\n", social["twitter"])
		}
	}
}

Why Each Assertion is Necessary ✅

1. 1st Assertion: Convert interface{} to []interface{} so we can use range

2. 2nd Assertion: Convert each array element from interface{} to map[string]interface{} so we can use bracket notation like user["name"]

3. 3rd Assertion: Convert nested objects from interface{} to map[string]interface{} for the same reason

Alternative Approaches

1. Use Structs for Known Schemas

If you know your JSON structure ahead of time, define structs:

type User struct {
	Name   string `json:"name"`
	Age    int    `json:"age"`
	Social struct {
		Twitter  string `json:"twitter"`
		Facebook string `json:"facebook"`
	} `json:"social"`
}

type Response struct {
	Users []User `json:"users"`
}

// Assuming jsonData is a []byte containing your JSON data
var response Response
json.Unmarshal(jsonData, &response)

// No type assertions needed!
for _, user := range response.Users {
	fmt.Printf("Name: %s\n", user.Name)
	fmt.Printf("Twitter: %s\n", user.Social.Twitter)
}

2. Use Libraries for Dynamic JSON

For dynamic JSON structures, consider libraries like gjson

import "github.com/tidwall/gjson"

// Assuming jsonString is a string containing your JSON data
result := gjson.Get(jsonString, "users")

result.ForEach(func(key, value gjson.Result) bool {
	fmt.Printf("Name: %s\n", value.Get("name").String())
	return true // continue iterating
})

Key Takeaways: Watch out for those Type Assertions

1. Static vs Runtime Types: Go variables have both compile-time and runtime types. How compile-time types actually helps in Go. More compile-time shenanigans from go.

2. Compiler Limitations: The compiler only uses static types to determine valid operations. A discussion.

3. Type Assertions: Change the static type to match the runtime type. When it fails, use https://pkg.go.dev/reflect to find the type.

4. Safety First: Always use the “comma ok” idiom to handle assertion failures.

5. Consider Alternatives: Structs for known schemas, specialized libraries for complex dynamic JSON.

The Mental Model

Think of type assertions as updating the compiler’s knowledge about your data:

• Before: “This could be anything” (`interface{}`)
• After: “This is definitely a slice” (`[]interface{}`)

The data itself never changes – only what the compiler allows you to do with it.

Understanding this distinction between static and runtime types is crucial for effective Go programming, especially when working with JSON, reflection, or any situation involving `interface{}`.

Footnote:

This explanation emerged from a real debugging session where the apparent contradiction between seeing `[]interface{}` as the type but being unable to iterate over it caused significant confusion. The key insight is that `%T` shows the runtime type, while the compiler operates on static types.*

That’s it for now, live in the mix.