Golang Interface: The Art of Runtime Polymorphism in Go Read it later

Have you ever wondered how Golang manages to incorporate the concept of polymorphism, similar to object-oriented programming? The secret lies in the Golang interface! In this blog, we’re going to embark on an exciting journey exploring the world of the Golang interface. From understanding their declaration and implementation to unraveling the mysteries of empty interfaces, composition, and type assertions, we have a wealth of knowledge waiting to be discovered. So, fasten your seatbelts and get ready to dive into this knowledge-packed blog. And hey, don’t forget to stick around for a fascinating fun fact about the Golang interface at the end!

What is Golang Interface?

In Go, an interface is a special type that defines a set of method signatures. It serves as a blueprint for the expected behavior of a type. By using interfaces, we can write code that operates on different types without worrying about their specific implementations. It promotes flexibility and modularity in our code.

For example, in a Zoo program, we can define an Animal interface with standard methods like MakeSound() and Move(), allowing us to work with different types of animals seamlessly.

Defining Interface in Golang

So, we’ve just explored the definition of a Golang interface. Are you feeling a bit confused? Well, I must admit that I also find it a bit perplexing when reading the definition alone. The good news is that the best way to truly grasp any concept is to dive into how it works in practice. Once we understand its workings, we’ll be able to connect the dots and make sense of that definition. So, let’s waste no time and take a closer look at the syntax of a Golang interface.

In Go, defining an interface is quite easy I would say. We use the type keyword followed by the name we want to assign to our interface. For instance, if we want to create an interface called “Messenger”, we would write:

type Messenger interface {
    // Method declarations go here
}

// OR

type Messenger = interface {
    // Method declarations go here
}

To define the methods that our interface should have, we simply list them within the curly braces. Each method is declared without any implementation details, only specifying the method signature. The method signature consists of the method name, any input parameters it requires (if applicable), and the return type(s) (if applicable).

Interface with the method signature:

type Messenger interface {
	Send(message string) error
	Receive() (string, error)
}

// OR

type Messenger = interface {
	Send(message string) error
	Receive() (string, error)
}

In this example, the Messenger interface specifies two methods:

1. Send, which takes a message of type string and returns an error, and
2. Receive, which returns a string and an error.

Any type that implements these two methods will automatically satisfy the Messenger interface.

Next, let’s explore how we can implement these interfaces and witness their functionality firsthand.

Implementing Golang Interface

Alright, we have defined our first interface, which is the Messenger interface. But you might be wondering, “What do we do with it now?” That’s a great question, so let’s explore how to implement and use Golang interfaces.

As mentioned earlier, any type that implements all the methods defined in an interface will automatically satisfy that interface. This is a fundamental concept to understand when working with Golang interfaces.

Let’s start by defining a struct type and see how it can implement the interface methods. Consider the following example:

type TextMessenger struct {
	// Fields specific to the TextMessenger struct
}

func (tm TextMessenger) SendMessage() {
	fmt.Println("Sending Text Message")
}

In the above code, we have defined a struct called TextMessenger, and it implements the SendMessage() method. This method defines the behavior of sending a text message.

Now, let’s see how we can initialize and use this struct in the context of interfaces:

func main() {
	var tm Messenger = TextMessenger{}
	fmt.Println("Type of tm is", reflect.TypeOf(tm))
}

In the main() function, we initialize an instance of TextMessenger and assign it to a variable tm of type Messenger. Notice that the type of tm is not TextMessenger, but Messenger. This is a unique aspect of working with interfaces in Go.

Output:

Type of tm is main.TextMessenger

You might be wondering if interfaces can be used as function parameters. Let’s explore that next:

func Notify(m Messenger) {
	m.SendMessage()
}

func main() {
	var tm TextMessenger = TextMessenger{}

	Notify(tm)
}

In the above example, we have a function called Notify that takes an input parameter of type Messenger. In the main() function, we pass an instance of TextMessenger as an argument to the Notify function.

Output:

Sending Text Message

Woah! It works. This demonstrates the power of interfaces in enabling runtime polymorphism (We are going to explore it later). The Notify function can accept any type that satisfies the Messenger interface, allowing for flexible and reusable code.

Use Cases of Golang Interface

It’s human psychology that we pay greater attention to learning when we already know how to put into effect a concept. So, if we want to be thorough with our Golang interface learning, now is the time to familiarise ourselves with Golang use cases so that you may picture how you can apply the interface in your project while reading the blog.

Let’s explore a few scenarios where interfaces shine:

1. Database Abstraction: Interfaces enable the creation of a database abstraction layer. By defining an interface for common database operations, we can write code that works with any database system. This allows easy switching between databases without changing the core logic of our application.
2. Plugins: Interfaces are valuable in building flexible plugin systems. Defining interfaces for required functionality allows dynamic loading and execution of plugins at runtime. This makes it easier to extend our application with new features without modifying the core codebase.
3. API Development: Interfaces play a key role in designing modular APIs. By defining interfaces for different components or services, we can integrate and swap implementations effortlessly. Loose coupling between modules promotes scalability and maintainability.
4. Dependency Injection: Interfaces facilitate dependency injection. By defining interfaces for dependencies, we can inject concrete implementations at runtime. This promotes testability, as we can easily substitute dependencies with mock implementations during unit testing.
5. Frameworks and Libraries: Interfaces are widely used in Golang frameworks and libraries for extensibility. Developers can implement specific interfaces to customize and extend the functionality of these tools without modifying the core codebase, promoting code reuse and a thriving ecosystem.

Internal Representation of Golang Interface

To gain a deeper understanding of how interfaces are represented internally in Golang, let’s explore their inner workings. By comprehending the internal representation, we can write more efficient and effective code.

Under the hood, a Golang interface comprises two crucial components: the type and the value. The type component represents the concrete type that implements the interface, while the value component stores the actual value of that type. This unique combination empowers an interface variable to hold and switch between different types.

To illustrate this concept, let’s consider a simple code example:

package main

import "fmt"

type Number interface {
	Value()
}

type IntFloat struct {
	value float64
}

func (i IntFloat) Value() {
	fmt.Println(i.value)
}

type Integer int

func (i Integer) Value() {
	fmt.Println(i)
}

func main() {
	var i Number
	i = Integer(1)
	fmt.Printf("(%T, %v)\n", i, i)
	i.Value()

	i = IntFloat{value: 1.1}
	fmt.Printf("(%T, %v)\n", i, i)
	i.Value()
}

In the above example, we define an interface called Number, which declares a single method called Value(). Additionally, we create two types, IntFloat and Integer, that both implement the Number interface by providing their respective Value() methods.

In the main() function, we demonstrate the internal representation of interfaces. We create an interface variable, i, of type Number and assign it different values of different types. Initially, we assign an Integer value of 1 to i and then print the type and value of i. We also invoke the Value() method on i.

Next, we reassign the interface variable i with an IntFloat value of 1.1. Again, we print the type and value of i, which now reflect the new type and value. Finally, we invoke the Value() method on i.

The output of the code will be:

(main.Integer, 1)
1
(main.IntFloat, {1.1})
1.1

As we can see from the example, Golang interfaces provide a powerful abstraction that allows us to work with different types through a common interface. The internal representation enables seamless type switching and flexibility, enabling us to write versatile and reusable code.

Golang Interface Types

In the vast world of Golang interfaces, you may have come across the terms “concrete value” and “concrete type“. If you missed it, don’t worry! We mentioned it briefly in the “Internal Representation” section. Now, in this section, we’ll dive deeper into the concept of Interface Types in Golang. But hold on! Don’t confuse it with “Types of Interfaces.” It’s actually about the “Types of Interface Types”.

As we explored the internal representation of Golang interfaces in the previous section and discovered that they internally hold a combination of a type and a value. Let’s dive further into this concept, and learn about static and dynamic interface types. Trust me, understanding these types is crucial for comprehending some advanced concepts related to Golang interfaces.

Let’s dive into each type with the help of an example. Imagine we have an interface named Messenger:

type Messenger interface {
	Send()
}

We also have two structs, TextMessage and VoiceMessage, that implements the Messenger interface:

type TextMessage struct {
	Msg string
}

func (t TextMessage) Send() {
	fmt.Println("Sending Text Message...")
}

type VoiceMessage struct {
	Msg string
}

func (v VoiceMessage) Send() {
	fmt.Println("Sending Voice Message...")
}

Now, let’s explore the types!

Static Interface Type

The static type of an interface variable is simply the interface itself. It remains the same throughout the program’s execution, regardless of the value it holds.

Example:

func main() {
	var m Messenger    // The static type of 'm' is Messenger
}

📝 Note: The static type of an interface variable never changes.

Dynamic Interface Type

An interface variable can represent multiple values, each having a different type. This type, which varies based on the value assigned to the interface variable, is known as the dynamic type of the interface.

Let’s understand this with an example, building upon the previous code:

func main() {
    var m Messenger                // The static type of 'm' is Messenger
    m = TextMessage{"Hello"}       // The dynamic type of 'm' is TextMessage
    fmt.Println(reflect.TypeOf(m)) // Output: main.TextMessage
    m = VoiceMessage{"Hello"}      // The dynamic type of 'm' is VoiceMessage
    fmt.Println(reflect.TypeOf(m)) // Output: main.VoiceMessage
}

When an interface variable is just initialized and doesn’t yet hold any value, the dynamic type is nil.

Example:

func main() {
	var m Messenger                // The static type of 'm' is Messenger
	fmt.Println(reflect.TypeOf(m)) // <nil>
}

Now that we have a clear idea about static and dynamic interface types, let’s address the first question we raised in this section: “What are concrete value and concrete type?”

An interface type variable contains a value of a type that implements the interface. The value of that type is known as the dynamic value, while the type itself is referred to as the dynamic type or, more commonly, the concrete value and concrete type.

Example:

func main() {
    var m Messenger                 // The static type of 'm' is Messenger
    m = TextMessage{"Hello"}        // The dynamic type of 'm' is TextMessage (Concrete Type)
    fmt.Println(reflect.ValueOf(m)) // The concrete value is {Hello} (Dynamic Value)
}

Understanding the distinction between static and dynamic types, as well as concrete values and types, lays a solid foundation for understanding advanced concepts related to Golang interfaces.

Runtime Polymorphism with interfaces

We’ve already touched upon the concept of polymorphism in the previous section, but it’s crucial enough to deserve its own dedicated section. So, let’s dive deeper into the concept of polymorphism.

what is Polymorphism?

Polymorphism refers to an object’s ability to take on multiple forms. In the context of object-oriented programming (OOPs), polymorphism is achieved when an object can be treated as an instance of its own class or as an instance of its parent class. This means that a single method can have different implementations in different classes.

Does Golang Support Polymorphism?

Now that we have a basic understanding of polymorphism, let’s explore whether Golang supports this fundamental concept in object-oriented programming. When evaluating whether a programming language supports polymorphism, we typically consider two main requirements: method overloading and method overriding.

However, Golang does not provide these features. So you might be wondering, does Golang even support polymorphism? The answer is yes, but in a different way – Golang supports runtime polymorphism implemented through interfaces.

But what exactly is runtime polymorphism? In runtime polymorphism, the method is resolved at runtime rather than at compile time. It’s important to note that interfaces in Golang differ from those in other object-oriented languages like Java. Let’s learn how!

Implicit Nature of Interfaces in Golang

When it comes to working with Golang interfaces, you may have noticed something strange, especially if you have worked with interfaces in other programming languages. It’s that moment when you find yourself wondering, “Wait, where’s the ‘implements‘ keyword?” Trust me, I’ve been there too!

In languages like Java, we explicitly declare that a class implements an interface using the “implements” keyword. Example:

public class MyClass implements MyInterface {
    // Implementing methods from MyInterface
}

However, in Golang, things work a bit differently. There’s no need for an explicit declaration of interface implementation. Surprising, isn’t it?

In Golang, the implementation of an interface follows an implicit approach. It means that a type automatically satisfies an interface without explicitly stating it. It’s a rather remarkable feature, and it’s known as the implicit nature of Golang interfaces.

Advantages of Implicit Nature of Interfaces

You may be wondering why Golang opted for implicit implementation instead of the explicit approach. Well, there are several advantages to this decision. Let’s explore some of them:

1. Decoupling Interface Definition and Implementation: With implicit interfaces, the definition of an interface is decoupled from its implementation. This means that the interface can exist independently and be implemented in any package without rearranging code or making explicit connections.
2. Encourages Duck Typing: Go follows the principle of “If it looks like a duck, and it quacks like a duck, then it is a duck“. With implicit interfaces, we focus on behavior rather than specific types.
3. Simplified Code Structure: By eliminating the need for explicit implementation declarations, Golang interfaces contribute to a cleaner and more concise code structure. You don’t have to clutter your code with explicit statements of an interface implementation, resulting in a more readable and structured codebase.

Achieving Runtime Polymorphism in Golang

If you recall the “implementation” section, the polymorphism definition may ring a bell. However, don’t worry if it still seems unclear. Let me break it down for you.

To better understand runtime polymorphism, let’s take an example of the Shape interface:

package main

import (
	"fmt"
	"reflect"
)

type Shape interface {
	Area() float64
}

type Rectangle struct {
	Length  float64
	Breadth float64
}

type Square struct {
	Side float64
}

func (r Rectangle) Area() float64 {
	return r.Length * r.Breadth
}

func (s Square) Area() float64 {
	return s.Side * s.Side
}

func PrintArea(s Shape) {
	fmt.Println("Type of shape is:", reflect.TypeOf(s))
	fmt.Println("Area of shape is:", s.Area())
}

func main() {
	r := Rectangle{Length: 5, Breadth: 4}
	s := Square{Side: 4}
	PrintArea(r)
	PrintArea(s)
}

In the above example, we have a Shape interface and two structs, Rectangle and Square. Both of these structs implement the Area() method, making them implicitly implement the Shape interface. So far, so good, right?

Now, let’s shift our focus to the PrintArea(s Shape) function. It takes a parameter of type Shape. This is where things get interesting.

In the main function, when we call the PrintArea() function, we pass instances of both the Rectangle and Square types as arguments. How is this possible?

Well, it’s possible because both of these structs implement the Shape interface. Consequently, they can be treated as instances of Shape. Remember the phrase “duck-typing”: If something looks like a duck and quacks like a duck, then it’s a duck. In our case, if something has the Area() function attached to it, we consider it a Shape.

Output

Type of shape is: main.Rectangle
Area of shape is: 20
Type of shape is: main.Square
Area of shape is: 16

So, where does the polymorphism come into play? In this example, do you see objects assuming multiple forms? Precisely! We have r and s representing different forms – their original struct types (Rectangle and Square, as shown by reflect package) and the interface type they implement (Shape). This is runtime polymorphism in action.

I hope this explanation clarifies the concept. If you have any questions or insights, feel free to share them in the comments.

Interface Composition

Now, let’s dive into the fascinating world of interface composition in Golang. This concept takes our understanding to an intermediate level, where we explore how Golang achieves some aspects of inheritance through interface composition.

In Golang, there is no native support for inheritance like in some other programming languages. However, Golang offers two powerful alternatives for inheritance through struct embedding and interface composition.

With interface composition, we can establish relationships between interfaces, allowing one interface to acquire the properties or identities of another. This enables us to create HAS-A relationships between interfaces, enhancing code modularity and reusability.

To better understand interface composition, let’s consider an example:

type Writer interface {
	Write(data []byte) (int, error)
}

type Reader interface {
	Read() ([]byte, error)
}

type ReadWriter interface {
	Reader
	Writer
}

In this example, we have three interfaces: Writer, Reader, and ReadWriter. The Writer interface defines a method called Write, while the Reader interface defines a method called Read. The interesting part comes with the ReadWriter interface, which embeds both the Reader and Writer interfaces.

By composition, the Reader and Writer interfaces into ReadWriter, the ReadWriter interface now inherits the methods from both the Reader and Writer interfaces. This means that any type implementing the ReadWriter interface must provide implementations for both the Read and Write methods.

Let’s see a code snippet to illustrate this concept further:

type File struct {
	// File-specific fields
}

func (f File) Read() ([]byte, error) {
	// Code to read from a file
}

func (f File) Write(data []byte) (int, error) {
	// Code to write to a file
}

func main() {
	var rw ReadWriter = File{}
	data := []byte("Hello, Golang!")
	_, err := rw.Write(data)
	if err != nil {
		// Error handling
	}

	// Further code to read or perform other operations
}

In this example, we have a File type that implements both the Read and Write methods. By assigning an instance of File to a variable of type ReadWriter, we can call the Write method on the ReadWriter interface, which in turn invokes the Write method of the File type.

Empty Interface in Go

Before diving into the concept of empty interfaces in Golang, let’s explore a scenario. Have you ever wondered how the Println() function in the fmt package is able to accept values of any kind as parameters? If you haven’t, it’s time to activate your thinking cap and ponder over how this is possible in Golang.

func main() {
	str := "Hello World"
	b := true
	i := 10
	f := 2.2
	fmt.Println(str)
	fmt.Println(b)
	fmt.Println(i)
	fmt.Println(f)
}

The answer lies in the concept of empty interfaces.

An empty interface is an intriguing concept in the Go programming language that can represent any type. Yes, you heard it right – any type!

Now that we understand what an empty interface is, let’s explore how we can create our own functions that can accept values of any type.

Golang Empty Interface Syntax

The syntax for an empty interface is as follows:

var ei interface{}

// or

var ei = interface{}

// or

type EI interface{}
var ei EI

fmt.Println(ei)    // Output: <nil>

Any – The Empty Interface Equivalent

Did you know that Golang offers an alternative to the empty interface type (interface{})? It’s called any. Just as its name suggests, it can represent any type of data. So, how do we use it? Let’s explore the syntax!

To declare a variable of type any, we simply write:

var a any

With this declaration, we can assign values of any type to the variable a.

But here’s an interesting fact: the any type is internally implemented as an alias for the interface{} type. It’s like saying:

type any = interface{}

This means that any and interface{} are essentially the same thing.

Representing Types in Golang Empty Interfaces

We can now represent different types in an empty interface. Let’s take a look at an example:

func main() {
    var ei interface{}

	ei = "Hello World"
	fmt.Println(ei)

	ei = 22.1
	fmt.Println(ei)

	ei = 15
	fmt.Println(ei)

	ei = true
	fmt.Println(ei)

	ei = []int{1, 2, 3}
	fmt.Println(ei)
}

As you can see, an empty interface can store values of any type.

Empty Interface as Function Parameter

An interesting application of empty interfaces is using them as function parameters. Now that we have a good understanding of empty interfaces, we can easily predict why we would need them as function arguments. Yes right! it allows us to accept values of any type. Sometimes, we don’t know what type of value our function will receive (similar to the fmt.Println() function), and that’s when empty interfaces come in handy.

Let’s consider an example:

func OurPrinter(i interface{}) {
	fmt.Println(i)
}

func main() {
	OurPrinter(42)
	OurPrinter("Hello")
	OurPrinter(3.14159)
}

In the example above, we’ve created our own simple printing function, OurPrinter(), that can print values of any type. By accepting an empty interface as a function parameter, we enable the function to handle various types of values.

Problem With Empty Interface

We have understood the basics of empty interfaces in Golang, but have you ever encountered any issues related to them? If not, let me give you an example that will make it clear.

Consider the following example:

package main

import "fmt"

func Doubler(i interface{}) {
	fmt.Println(i * 2)
}

func main() {
	Doubler(42)
	Doubler(3.14159)
}

In the above example, we have a Doubler(i interface{}) function that takes an empty interface as a parameter. So far, everything seems normal, as we discussed earlier. But when you run this code, an error will be thrown:

invalid operation: i * 2 (mismatched types interface{} and int)

Now, can you figure out why this error occurs? Let’s dive into the reason behind it.

The Doubler() function accepts an empty interface and performs an operation on it (i * 2). In the main function, we call the Doubler() function with two different types: int and float. And here lies the problem. The empty interface can accept any type, but in order to perform an operation on it, Golang needs to know the specific type of the value.

So, does that mean it’s not possible in Golang to work with values of different types through an empty interface? Well, there is a solution to this problem. In the next section, we will explore the concepts of type assertion and type switches, which will allow us to handle this situation effectively.

Type Assertion and Type Switches

In the previous section, we encountered a challenge with empty interfaces. As you may recall, an empty interface in Golang has the power to represent any type of value, but as the famous quote from Spiderman reminds us, “With great power, comes great responsibilities“. In the case of empty interfaces, the responsibility lies in fetching values of different types so that we can perform operations on them. To fulfill this responsibility, Golang provides us with type assertion and Type Switches with interfaces. Let’s delve into these concepts now.

Understanding Type Assertion in Golang

In the Go language, type assertion allows us to extract the values from an interface. It is an operation performed on the value of the interface, providing access to the underlying concrete value.

Now, enough theory. Let’s take a look at the syntax of type assertion:

t := i.(T)

This statement asserts that the interface value i holds the concrete type T and assigns the underlying value of type T to the variable t.

However, if i does not hold the type T, the statement will trigger a panic.

To test whether an interface value holds a specific type, a type assertion can return two values: the underlying value and a boolean value indicating whether the assertion succeeded.

t, ok := i.(T)

If i holds the type T, then t will receive the underlying value, and ok will be true. On the other hand, if i does not hold the type T, ok will be false, and t will be the zero value of type T. In this case, no panic occurs.

Let’s see an example to illustrate how type assertion works:

package main

import "fmt"

func main() {
	var i interface{} = "hello"

	s := i.(string)
	fmt.Println(s)

	s, ok := i.(string)
	fmt.Println(s, ok)

	f, ok := i.(float64)
	fmt.Println(f, ok)

	f = i.(float64) // This will cause a panic
	fmt.Println(f)
}

In this example, we create an interface i with the value “hello.” We then perform type assertions to extract the underlying string value.

The first type assertion assigns the string value to s, and the second type assertion assigns the string value to s and also checks if the assertion succeeded by using the boolean variable ok.

In the third type assertion, we attempt to assign a float64 value to f, which fails and sets ok to false. Lastly, the fourth type assertion triggers a panic since the underlying value is not of type float64.

📝 Note: There is a similarity between the syntax of type assertion and accessing values from a map.

Type Switches in Golang

But wait, our Doubler() function from the “Empty Interface” section is still not giving desired output. Although type assertions allowed us to extract specific types of values, they didn’t provide a solution for extracting values of multiple types. This is where type switches come into play. Let’s delve into this powerful construct now.

What is a Type Switch in Golang?

A type switch in Golang is a construct that allows us to perform multiple type assertions in a series. It resembles a regular switch statement, but instead of comparing values, the cases in a type switch specify types. These types are then matched against the actual type of the value stored in the interface variable.

The syntax for a type switch is similar to a type assertion, but instead of specifying a specific type, we use the keyword “type”. Here’s how it looks:

switch v := i.(type) {
case T:
    // Here, v has the type T
case S:
    // Here, v has the type S
default:
    // No match
}

In this switch statement, we test whether the interface value i holds a value of type T or S. In each case, the variable v will have the respective type (T or S) and hold the value contained within i. And if no case matches the control will go to the default case.

Completing Our Doubler Function

Now, let’s revisit our Doubler example and enhance it using a type switch:

func Doubler(i interface{}) {
    // Type switch
    switch i := i.(type) {
    case int:
        fmt.Println(i * 2)
    case float64:
        fmt.Println(i * 2)
    case string:
        fmt.Println(i + i)
    default:
        fmt.Printf("I don't know about type %T!\n", i)
    }
}

func main() {
    var i interface{} = 25
    Doubler(17)
    Doubler(17.5)
    Doubler("Hello")
    Doubler(i)
    Doubler(true)
}

Output:

34
35
HelloHello
50
I don't know about type bool!

In this updated Doubler function, we utilize a type switch to handle different types of values passed to it. Depending on the type of argument, we perform specific operations and generate the desired output.

Fun Fact!

Did you know that the creators of Golang drew inspiration for Interfaces from the Smalltalk programming language, developed by Alan Kay, Dan Ingalls, and Adele Goldberg in the 1970s-1980s? Smalltalk’s principle that “everything is an object” and “any object could receive any message” fascinated the Golang creators.

To achieve similar power and flexibility in a mostly statically typed language, Golang introduced interfaces for static typing. Unlike other languages, Golang attached type information to interfaces rather than objects. This insight allowed developers to attach methods to any type, making object-oriented programming in Golang an easy task.

So, the next time you code in Golang, remember the Smalltalk influence and how interfaces revolutionized object-oriented programming in this modern language.

Share this fun fact with your friends and show off your extra knowledge about Golang!

Wrapping Up

In conclusion, Golang interfaces are a crucial aspect of Go programming, enabling flexible and maintainable code. We’ve explored their declaration, implementation, and practical use cases. By leveraging runtime polymorphism and interface composition, we can create modular and reusable code. Best practices and design principles further enhance interface-driven development. Embrace the power of Golang interfaces to write efficient and adaptable code. Happy coding!

Frequently Asked Questions (FAQs)

Reference

1. Golang interface documentation: https://golang.org/doc/effective_go#interfaces
2. Golang tour on interfaces: https://tour.golang.org/methods/9
3. Golang Interface Inspiration: https://go.dev/talks/2015/gophercon-goevolution.slide#19