Duck Typing in Go: The Quackable Interface

Duck typing is a programming style where an object's suitability is determined by its methods and properties rather than its type. In Go, which is statically typed, we can achieve duck typing through interfaces. This challenge asks you to implement a system that leverages interfaces to treat different types uniformly, as long as they "quack" (i.e., implement the necessary methods).

Problem Description

You are tasked with creating a system that can process various "Quackable" objects. A Quackable object is defined by its ability to perform a Quack() action, which returns a string. Your system should accept any object that implements the Quack() method and process it accordingly, without needing to know its concrete type.

Specifically, you need to:

1. Define an interface named Quackable with a single method Quack() string.
2. Create three concrete types: Duck, Dog, and Robot.
   • Duck should return "Quack!" when Quack() is called.
   • Dog should return "Woof!" when Quack() is called.
   • Robot should return "Beep Boop!" when Quack() is called.
3. Write a function ProcessQuackable(q Quackable) that accepts a Quackable object as input. This function should call the Quack() method on the input object and print the returned string to the console.
4. Demonstrate the functionality by creating instances of Duck, Dog, and Robot and passing them to the ProcessQuackable function.

Examples

Example 1:

Input: Duck{breed: "Mallard"}
Output: Quack!
Explanation: The ProcessQuackable function receives a Duck object, calls its Quack() method, which returns "Quack!", and prints it.

Example 2:

Input: Dog{name: "Buddy"}
Output: Woof!
Explanation: The ProcessQuackable function receives a Dog object, calls its Quack() method, which returns "Woof!", and prints it.

Example 3:

Input: Robot{model: "RX-8"}
Output: Beep Boop!
Explanation: The ProcessQuackable function receives a Robot object, calls its Quack() method, which returns "Beep Boop!", and prints it.

Constraints

• The Quack() method must return a string.
• The ProcessQuackable function must not use type assertions or type switches to determine the type of the input object. It should rely solely on the interface.
• All types must be defined within the same Go file.

Notes

• This challenge demonstrates how Go's interfaces enable duck typing. The ProcessQuackable function doesn't care about the specific type of the object; it only cares that it implements the Quack() method.
• Consider how this approach promotes code flexibility and reusability. You can easily add new types that implement Quackable without modifying the ProcessQuackable function.
• Think about the benefits of using interfaces for abstraction and polymorphism.