Defining methods in Go - Step-by-Step Execution

Concept Flow - Defining methods

Define struct type

↓

Define method with receiver

↓

Create instance of struct

↓

Call method on instance

↓

Method runs using instance data

↓

Return or print result

↓

End

This flow shows how to define a method on a struct type, create an instance, and call the method to use the instance's data.

Execution Sample

Go

package main
import "fmt"
type Person struct { name string }
func (p Person) Greet() string { return "Hello, " + p.name }
func main() {
 p := Person{name: "Anna"}
 fmt.Println(p.Greet())
}

This code defines a method Greet on Person struct and calls it to print a greeting.

Execution Table

Step	Action	Evaluation	Result
1	Define struct Person with field name	No output	Person type ready
2	Define method Greet with receiver p Person	No output	Method Greet linked to Person
3	Create instance p = Person{name: "Anna"}	p.name = "Anna"	Instance p created
4	Call p.Greet()	Concatenate "Hello, " + p.name	"Hello, Anna"
5	Print result of p.Greet()	Output to console	Hello, Anna

💡 Program ends after printing greeting

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
p	undefined	Person{name: "Anna"}	Person{name: "Anna"}	Person{name: "Anna"}
p.name	undefined	"Anna"	"Anna"	"Anna"

Key Moments - 3 Insights

Why do we write (p Person) before the method name?

This part defines the method receiver, meaning the method works on a Person instance named p. See execution_table step 2 where method links to Person.

Does the method change the original Person instance?

No, because the receiver is a value copy (not a pointer). The method uses a copy of p. See variable_tracker where p stays the same after method call.

How does the method access the name field?

Inside the method, p.name accesses the name of the Person instance passed as receiver. See execution_table step 4 where p.name is used.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of p.name used in the method?

A "Person"

B "Hello"

C "Anna"

D "Greet"

💡 Hint

Check the 'Evaluation' column at step 4 in execution_table where p.name is concatenated.

At which step is the method Greet linked to the Person type?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table step 2 where method definition happens.

If we changed the receiver to a pointer like (p *Person), what would happen to the variable p after calling Greet?

A p could be modified inside the method

B p would be unchanged

C p would be nil

D p would become a copy

💡 Hint

Refer to key_moments about receiver type and variable_tracker showing p unchanged with value receiver.

Concept Snapshot

Defining methods in Go:
- Use func (receiver Type) MethodName() syntax
- Receiver links method to struct type
- Methods can access receiver fields
- Value receivers get a copy; pointer receivers can modify original
- Call methods on instances with instance.MethodName()

Full Transcript

This example shows how to define a method on a struct in Go. First, we define a struct Person with a name field. Then, we define a method Greet with a receiver p of type Person. This method returns a greeting string using p.name. In main, we create an instance p with name "Anna". Calling p.Greet() runs the method using p's data and returns "Hello, Anna". The method uses a value receiver, so it works on a copy of p and does not modify the original. The program prints the greeting and ends.

Practice

1. What is the purpose of defining a method with a receiver in Go?

easy

A. To import external packages into the program

B. To create a standalone function unrelated to any type

C. To associate a function with a specific type so it can act on its data

D. To declare a global variable accessible everywhere

Solution

1. Step 1: Understand what a receiver does

   A receiver connects a method to a type, allowing the method to access or modify that type's data.

2. Step 2: Compare with other options

   Options A, B, and C describe unrelated concepts: imports, standalone functions, and global variables.

3. Final Answer:

   To associate a function with a specific type so it can act on its data -> Option C

4. Quick Check:

   Receiver links method to type = D [OK]

Hint: Receiver connects method to type's data [OK]

Common Mistakes:

• Thinking methods are standalone functions
• Confusing methods with variables
• Believing receivers import packages

2. Which of the following is the correct syntax to define a method named Speak for a struct type Dog?

easy

A. func (d Dog) Speak() { }

B. func Speak(d Dog) { }

C. func Dog.Speak() { }

D. func Speak() Dog { }

Solution

1. Step 1: Recall Go method syntax

   Methods use the form: func (receiver Type) MethodName() { }.

2. Step 2: Match syntax to options

   func (d Dog) Speak() { } matches this pattern exactly. func Speak(d Dog) { } is a function, not a method. func Dog.Speak() { } is invalid syntax. func Speak() Dog { } is a function returning Dog, not a method.

3. Final Answer:

   func (d Dog) Speak() { } -> Option A

4. Quick Check:

   Method syntax = func (receiver Type) Name() [OK]

Hint: Method syntax always has receiver in parentheses before name [OK]

Common Mistakes:

• Omitting receiver parentheses
• Using dot notation in function name
• Confusing methods with functions

3. What will be the output of this Go program?

package main
import "fmt"
type Counter struct { value int }
func (c Counter) Increment() {
    c.value++
}
func main() {
    c := Counter{value: 5}
    c.Increment()
    fmt.Println(c.value)
}

medium

A. 6

B. 5

C. 0

D. Compilation error

Solution

1. Step 1: Understand receiver type in Increment method

   The method uses a value receiver (c Counter), so it works on a copy of the struct, not the original.

2. Step 2: Trace the method call and print

   Increment increases the copy's value, but original c.value remains 5. So printing c.value outputs 5.

3. Final Answer:

   5 -> Option B

4. Quick Check:

   Value receiver does not modify original = 5 [OK]

Hint: Value receiver copies data; original stays unchanged [OK]

Common Mistakes:

• Assuming value receiver changes original data
• Confusing pointer and value receivers
• Expecting incremented output

4. Identify the error in this method definition:

package main
import "fmt"
type Person struct { name string }
func (p *Person) SetName(newName string) {
    p.name = newName
}
func main() {
    p := Person{name: "Alice"}
    p.SetName("Bob")
    fmt.Println(p.name)
}

medium

A. No error; code runs and prints 'Bob'

B. Cannot call method with pointer receiver on value variable

C. Method must return a value

D. Missing import of fmt package

Solution

1. Step 1: Check pointer receiver usage

   In Go, methods with pointer receivers can be called on value variables; Go automatically takes address.

2. Step 2: Verify imports and method behavior

   Code imports fmt, method sets name correctly, so p.name becomes "Bob" and prints it.

3. Final Answer:

   No error; code runs and prints 'Bob' -> Option A

4. Quick Check:

   Pointer receiver works on value variable = B [OK]

Hint: Pointer receiver methods can be called on values directly [OK]

Common Mistakes:

• Thinking pointer receiver requires pointer variable
• Forgetting Go auto-addressing
• Expecting compile error

5. You want to define a method Reset for a struct Timer that sets its seconds field to zero. Which receiver type should you use and why? Options: A) Pointer receiver, because it modifies the original struct's field B) Value receiver, because it copies the struct and resets the copy C) Value receiver, because methods cannot have pointer receivers D) Pointer receiver, but it cannot modify fields inside the struct

hard

A. Pointer receiver, but it cannot modify fields inside the struct

B. Value receiver, because it copies the struct and resets the copy

C. Value receiver, because methods cannot have pointer receivers

D. Pointer receiver, because it modifies the original struct's field

Solution

1. Step 1: Understand effect of receiver types on struct modification

   Value receivers work on copies, so changes do not affect original struct fields.

2. Step 2: Choose pointer receiver to modify original

   Pointer receivers allow methods to change the original struct's fields, so Reset can set seconds to zero effectively.

3. Final Answer:

   Pointer receiver, because it modifies the original struct's field -> Option D

4. Quick Check:

   Pointer receiver modifies original struct = A [OK]

Hint: Use pointer receiver to change original struct fields [OK]

Common Mistakes:

• Using value receiver expecting original change
• Believing methods can't have pointer receivers
• Thinking pointer receiver can't modify fields