Emulating Structural Typing in Go

Go is known for its nominal typing system, meaning types are compatible only if they have the same name and underlying structure. This challenge asks you to explore ways to emulate Go's structural typing capabilities, allowing for flexibility where different types can be treated interchangeably if they share a common set of methods. This is particularly useful when designing APIs or libraries that need to accept a variety of underlying implementations without requiring explicit inheritance.

Problem Description

Your task is to design and implement a system in Go that mimics structural typing. Specifically, you will need to:

1. Define an Interface: Create an interface that represents a "contract" of methods. This contract should be broad enough to be implemented by multiple distinct concrete types.
2. Implement the Interface: Create at least two different concrete struct types that implement the methods defined in your interface. These structs should have different underlying fields and purposes but fulfill the required methods.
3. Demonstrate Polymorphism: Write a function that accepts a variable of the interface type. This function should be able to process any concrete type that implements the interface without needing to know the specific concrete type at compile time.
4. Showcase Compatibility: Prove that your concrete types are compatible with the interface by passing instances of them to the polymorphic function.

Key Requirements:

• The interface should define at least two methods.
• The concrete types should be distinct and have different underlying data.
• The polymorphic function should call the methods defined in the interface.
• The output should clearly demonstrate that different concrete types can be used interchangeably through the interface.

Expected Behavior:

When an instance of a concrete type is passed to the polymorphic function, the function should execute the corresponding methods on that instance, behaving as if it were working directly with the interface type.

Edge Cases to Consider:

• What happens if a type implements only a subset of the interface methods? (Go's compiler will prevent this if the type is declared to implement the interface).
• Consider how your concrete types might handle different internal states, and how the interface methods would reflect that.

Examples

Example 1:

Let's imagine a scenario where we need to process "printable" things.

Input:
// Define a Printable interface
type Printable interface {
    String() string // Returns a string representation
    PrintDetails() string // Returns more detailed information
}

// Define a concrete type for a Book
type Book struct {
    Title  string
    Author string
    Pages  int
}

// Implement Printable for Book
func (b Book) String() string {
    return b.Title
}

func (b Book) PrintDetails() string {
    return fmt.Sprintf("Title: %s, Author: %s, Pages: %d", b.Title, b.Author, b.Pages)
}

// Define a concrete type for a Computer
type Computer struct {
    Brand string
    Model string
    RAM   int // in GB
}

// Implement Printable for Computer
func (c Computer) String() string {
    return c.Brand + " " + c.Model
}

func (c Computer) PrintDetails() string {
    return fmt.Sprintf("Brand: %s, Model: %s, RAM: %dGB", c.Brand, c.Model, c.RAM)
}

// A function that uses the Printable interface
func DisplayItem(item Printable) {
    fmt.Printf("--- Displaying Item ---\n")
    fmt.Printf("Basic Info: %s\n", item.String())
    fmt.Printf("Details: %s\n", item.PrintDetails())
    fmt.Printf("-----------------------\n")
}

// Main execution
func main() {
    myBook := Book{Title: "The Hitchhiker's Guide to the Galaxy", Author: "Douglas Adams", Pages: 224}
    myComputer := Computer{Brand: "Acme", Model: "Xylo", RAM: 16}

    DisplayItem(myBook)
    DisplayItem(myComputer)
}

Output:

--- Displaying Item ---
Basic Info: The Hitchhiker's Guide to the Galaxy
Details: Title: The Hitchhiker's Guide to the Galaxy, Author: Douglas Adams, Pages: 224
-----------------------
--- Displaying Item ---
Basic Info: Acme Xylo
Details: Brand: Acme, Model: Xylo, RAM: 16GB
-----------------------

Explanation:

The DisplayItem function accepts any type that implements the Printable interface. It calls the String() and PrintDetails() methods on the provided item without knowing whether item is a Book or a Computer. This demonstrates that both Book and Computer can be treated polymorphically because they both satisfy the Printable contract.

Constraints

• Your solution must be written entirely in Go.
• You must define at least one interface and at least two distinct concrete struct types that implement that interface.
• You must create at least one function that accepts the interface type as an argument and calls its methods.
• The output should be clear and demonstrate the polymorphic behavior.

Notes

• This challenge is about understanding Go's interface system and how it enables a form of structural typing.
• You don't need to implement complex generics or reflection. Stick to standard Go interface features.
• Think about common scenarios where different types might share a set of behaviors, such as data serialization, logging, or event handling.
• The goal is to show how you can write code that is agnostic to the specific concrete type, as long as it adheres to a defined set of methods.