Interface satisfaction in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Go program using interface satisfaction?

Consider the following Go code. What will it print when run?

Go

package main

import "fmt"

type Speaker interface {
	Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
	return "Woof!"
}

type Cat struct {}

func (c Cat) Speak() string {
	return "Meow!"
}

func saySomething(s Speaker) {
	fmt.Println(s.Speak())
}

func main() {
	d := Dog{}
	c := Cat{}

	saySomething(d)
	saySomething(c)
}

A Woof!\nWoof!

B Woof!\nMeow!

C Meow!\nWoof!

D Compilation error: Dog does not implement Speaker

💡 Hint

Check which types implement the Speak() method of the Speaker interface.

Both Dog and Cat types implement the Speak() method, so both satisfy the Speaker interface. The saySomething function calls Speak() on each, printing their respective sounds.

❓ Predict Output

intermediate

What error does this Go code produce regarding interface satisfaction?

Look at this Go code snippet. What error will it produce when compiled?

Go

package main

import "fmt"

type Reader interface {
	Read(p []byte) (n int, err error)
}

type MyReader struct {}

func (r *MyReader) Read(p []byte) (int, error) {
	return 0, nil
}

func main() {
	var r Reader = MyReader{}
	fmt.Println(r)
}

A cannot use MyReader{} (type MyReader) as type Reader in assignment: MyReader does not implement Reader (Read method has pointer receiver)

B nil

C Compilation error: missing Read method

D Program runs and prints: {}

💡 Hint

Check if the method receiver type matches the interface implementation.

The Read method has a pointer receiver (*MyReader), but the variable r is assigned a value of type MyReader (non-pointer). This causes a compile-time error because MyReader does not implement Reader, only *MyReader does.

🔧 Debug

advanced

Why does this Go program panic at runtime when using interface satisfaction?

Examine the code below. It compiles but panics at runtime. Why?

Go

package main

import "fmt"

type Printer interface {
	Print()
}

type Document struct {
	content string
}

func (d Document) Print() {
	fmt.Println(d.content)
}

func main() {
	var p Printer
	p.Print()
}

A p is nil interface, calling Print() causes runtime panic: nil pointer dereference

B Compilation error: Printer interface not implemented

C Program prints empty line

D Program prints zero value of Document

💡 Hint

What is the value of p before calling Print()?

The variable p is declared but not assigned any value, so it is nil. Calling a method on a nil interface causes a runtime panic.

📝 Syntax

advanced

Which option correctly implements interface satisfaction with embedded interfaces?

Given these interfaces, which implementation satisfies the Composite interface?

Go

package main

type Reader interface {
	Read(p []byte) (n int, err error)
}

type Writer interface {
	Write(p []byte) (n int, err error)
}

type Composite interface {
	Reader
	Writer
}

// Which struct and methods satisfy Composite?

A type RW struct{}\nfunc (rw *RW) Write(p []byte) (int, error) { return 0, nil }

B type RW struct{}\nfunc (rw *RW) Read(p []byte) (int, error) { return 0, nil }\nfunc (rw RW) Write(p []byte) (int, error) { return 0, nil }

C type RW struct{}\nfunc (rw RW) Read(p []byte) (int, error) { return 0, nil }

D type RW struct{}\nfunc (rw RW) Read(p []byte) (int, error) { return 0, nil }\nfunc (rw RW) Write(p []byte) (int, error) { return 0, nil }

💡 Hint

Both Read and Write methods must be implemented with matching receiver types.

Option D implements both Read and Write with value receiver RW, satisfying Composite. Option D has mixed receivers, so RW value does not satisfy Composite. Options C and D miss one method.

🚀 Application

expert

How many items are in the slice after interface satisfaction and type assertion?

What is the length of the slice 'speakers' after the code runs?

Go

package main

import "fmt"

type Speaker interface {
	Speak() string
}

type Human struct {
	name string
}

func (h Human) Speak() string {
	return "Hello, " + h.name
}

func main() {
	speakers := []Speaker{}

	h1 := Human{"Alice"}
	h2 := Human{"Bob"}

	speakers = append(speakers, h1)

	var s Speaker = h2
	if h, ok := s.(Human); ok {
		speakers = append(speakers, h)
	}

	fmt.Println(len(speakers))
}

A 0

B 1

C 2

D Compilation error

💡 Hint

Check how many times append is called and what is appended.

The slice speakers starts empty. h1 is appended once. Then s holds h2 as Speaker interface. The type assertion succeeds, so h2 is appended again. Total length is 2.