Type inference in Go - Step-by-Step Execution

Concept Flow - Type inference

Declare variable with :=

↓

Compiler infers type

↓

Variable gets type automatically

↓

Use variable in code

↓

Program runs with inferred types

In Go, when you declare a variable using :=, the compiler automatically figures out the variable's type from the assigned value.

Execution Sample

Go

package main
import "fmt"
func main() {
  x := 42
  fmt.Println(x)
}

This code declares x with :=, so Go infers x is an int, then prints 42.

Execution Table

Step	Code Line	Action	Type Inferred	Variable Value
1	x := 42	Declare x with :=, compiler infers type	int	42
2	fmt.Println(x)	Print value of x	int	42
3	End	Program ends	-	-

💡 Program ends after printing the value; type inference done at declaration.

Variable Tracker

Variable	Start	After Declaration	Final
x	undefined	42 (int)	42 (int)

Key Moments - 2 Insights

Why don't we write the type explicitly when using :=?

Because the compiler infers the type from the assigned value at declaration, as shown in execution_table step 1.

Can the type of x change after declaration?

No, once inferred, the variable's type is fixed; x remains int as shown in variable_tracker.

Visual Quiz - 3 Questions

Look at the execution table, what type is inferred for x at step 1?

A float64

B string

C int

D bool

💡 Hint

Check the 'Type Inferred' column in execution_table row for step 1.

At which step does the program print the value of x?

A Step 2

B Step 1

C Step 3

D No printing occurs

💡 Hint

Look at the 'Action' column in execution_table to find when fmt.Println is called.

If we change x := 42 to x := "hello", what type would be inferred?

A int

B string

C bool

D float64

💡 Hint

Type inference depends on the assigned value's type, see execution_table step 1.

Concept Snapshot

Type inference in Go:
- Use := to declare and assign
- Compiler infers variable type automatically
- Type fixed after inference
- Simplifies code by skipping explicit types

Full Transcript

This example shows how Go infers the type of a variable when declared with :=. The compiler looks at the assigned value and decides the type automatically. Here, x is assigned 42, so x is an int. The program then prints x's value. The type stays fixed as int throughout. This makes code shorter and easier to write without losing type safety.

Practice

1. What does type inference mean in Go when you write x := 10 inside a function?

easy

A. You must tell Go the type of x explicitly.

B. Go automatically figures out that x is an int.

C. Go treats x as a string by default.

D. The variable x has no type.

Solution

1. Step 1: Understand the := operator in Go

   The := operator declares a variable and assigns a value, letting Go guess the type.

2. Step 2: Check the assigned value type

   Since 10 is an integer, Go infers the type of x as int automatically.

3. Final Answer:

   Go automatically figures out that x is an int. -> Option B

4. Quick Check:

   Type inference means Go guesses type from value [OK]

Hint: := means declare and infer type from value [OK]

Common Mistakes:

• Thinking you must always write the type explicitly
• Assuming variables have no type
• Believing Go defaults to string type

2. Which of the following is the correct way to declare and assign a variable with type inference inside a function in Go?

easy

A. x := 5

B. x = 5

C. var x int = 5

D. int x = 5

Solution

1. Step 1: Recall Go syntax for type inference

   Inside functions, := declares and assigns a variable with inferred type.

2. Step 2: Check each option

   var x int = 5 declares with explicit type, not inference. x = 5 misses declaration. int x = 5 is invalid Go syntax.

3. Final Answer:

   x := 5 -> Option A

4. Quick Check:

   Use := to declare and infer type [OK]

Hint: Use := inside functions for type inference [OK]

Common Mistakes:

• Using C or D which are invalid Go syntax
• Forgetting to declare variable before assignment
• Confusing var declaration with :=

3. What is the output of this Go program?

package main
import "fmt"
func main() {
    x := 3.14
    fmt.Printf("%T", x)
}

medium

A. float64

B. float32

C. int

D. string

Solution

1. Step 1: Identify the type inferred for 3.14

   In Go, untyped floating-point constants default to float64 when assigned with :=.

2. Step 2: Understand fmt.Printf with %T

   The %T verb prints the type of the variable, so it will print "float64".

3. Final Answer:

   float64 -> Option A

4. Quick Check:

   Float literals default to float64 [OK]

Hint: Float literals default to float64 type [OK]

Common Mistakes:

• Assuming float32 is default
• Thinking 3.14 is int
• Confusing %T output with value

4. What is wrong with this Go code snippet?

func main() {
    var x := 10
    fmt.Println(x)
}

medium

A. The value 10 is not a valid integer.

B. x is not declared before use.

C. You cannot use := with var keyword.

D. fmt.Println is not imported.

Solution

1. Step 1: Understand variable declaration syntax

   In Go, := is shorthand for declaration and assignment without var keyword.

2. Step 2: Identify the syntax error

   Using var and := together is invalid syntax; you must use either var x = 10 or x := 10.

3. Final Answer:

   You cannot use := with var keyword. -> Option C

4. Quick Check:

   var and := cannot be combined [OK]

Hint: Don't combine var and := in one statement [OK]

Common Mistakes:

• Mixing var and := together
• Ignoring import errors (not shown here)
• Thinking := works outside functions

5. Given this Go code, what is the type of result after execution?

func main() {
    a := 5
    b := 2.0
    result := a * int(b)
    fmt.Printf("%T", result)
}

hard

A. float64

B. string

C. float32

D. int

Solution

1. Step 1: Analyze variable types and conversion

   a is int, b is float64 (default for 2.0). The expression converts b to int before multiplication.

2. Step 2: Determine result type

   Multiplying int (a) by int (converted b) results in int type for result.

3. Final Answer:

   int -> Option D

4. Quick Check:

   int * int = int type [OK]

Hint: Type conversion affects result type [OK]

Common Mistakes:

• Assuming result is float64 without conversion
• Forgetting to convert float to int
• Confusing multiplication type rules