Interface satisfaction in Go - Step-by-Step Execution

Concept Flow - Interface satisfaction

Define Interface

↓

Define Struct

↓

Check if Struct has all Interface Methods

Yes↓

Struct satisfies Interface

↓

Use Struct as Interface Type

The program defines an interface and a struct, then checks if the struct implements all interface methods to satisfy the interface, allowing it to be used as that interface type.

Execution Sample

Go

package main
import "fmt"
type Speaker interface {
    Speak() string
}
type Person struct {
    name string
}
func (p Person) Speak() string {
    return "Hello, " + p.name
}
func main() {
    var s Speaker
    p := Person{name: "Alice"}
    s = p
    fmt.Println(s.Speak())
}

This code shows a struct Person implementing the Speaker interface by defining Speak(), then using a Person as a Speaker.

Execution Table

Step	Action	Evaluation	Result
1	Define interface Speaker with method Speak()	Interface Speaker created	Speaker requires Speak() string
2	Define struct Person with field name	Struct Person created	Person{name string}
3	Define method Speak() on Person	Person now has Speak() method	Person satisfies Speaker interface
4	In main, declare variable s of type Speaker	s is nil interface variable	s = nil
5	Create Person p with name "Alice"	p = Person{name:"Alice"}	p holds data
6	Assign p to s (interface variable)	Check if Person satisfies Speaker	Yes, assignment allowed
7	Call s.Speak()	Calls Person.Speak()	Returns "Hello, Alice"
8	Print result	Output to console	Hello, Alice

💡 Program ends after printing the greeting string.

Variable Tracker

Variable	Start	After Step 5	After Step 6	After Step 7	Final
s	nil	nil	Person{name:"Alice"}	Person{name:"Alice"}	Person{name:"Alice"}
p	undefined	Person{name:"Alice"}	Person{name:"Alice"}	Person{name:"Alice"}	Person{name:"Alice"}

Key Moments - 3 Insights

Why can we assign a Person to a Speaker variable without explicit declaration?

Because Person has a method Speak() matching the Speaker interface, Go automatically knows Person satisfies Speaker (see execution_table step 6).

What happens if Person does not implement Speak()?

The assignment s = p would fail to compile because Person wouldn't satisfy Speaker (refer to execution_table step 6 where the check happens).

Does the interface variable s hold the actual Person data or just a reference?

The interface variable s holds a copy of the Person value and the method set, so calling s.Speak() uses Person's method (see variable_tracker after step 6).

Visual Quiz - 3 Questions

Look at the execution_table at step 6, why is the assignment s = p allowed?

A Because Person has a Speak() method matching Speaker interface

B Because s is declared as Person type

C Because p is an interface variable

D Because Speak() returns an int

💡 Hint

Check execution_table step 6 where the interface satisfaction is confirmed.

According to variable_tracker, what is the value of s after step 7?

A nil

B Person{name:"Alice"}

C Speaker interface with no value

D Empty string

💡 Hint

Look at variable_tracker column 'After Step 7' for variable s.

If Person did not implement Speak(), what would happen at step 6?

A Assignment would succeed anyway

B Program would panic at runtime

C Compilation error due to interface not satisfied

D Speak() would be called on nil

💡 Hint

Refer to key_moments about interface satisfaction and execution_table step 6.

Concept Snapshot

Interface satisfaction in Go:
- Define interface with method signatures
- Define struct with matching methods
- Struct automatically satisfies interface if all methods match
- Assign struct value to interface variable
- Call interface methods which invoke struct's implementations

Full Transcript

This example shows how a Go struct satisfies an interface by implementing all required methods. The interface Speaker requires a Speak() method returning a string. The struct Person defines Speak() returning a greeting with its name. In main, a variable s of type Speaker is declared. A Person value p is created with name "Alice". Assigning p to s works because Person satisfies Speaker. Calling s.Speak() calls Person's Speak() method and prints "Hello, Alice". The variable tracker shows s holds the Person value after assignment. If Person lacked Speak(), the assignment would fail to compile. This demonstrates Go's implicit interface satisfaction by method matching.