Embrace the Quack: Implementing Duck Typing in Go

Go, while statically typed, offers powerful ways to achieve polymorphism without explicit inheritance. This challenge focuses on understanding and implementing the concept of "duck typing" – the idea that "if it walks like a duck and it quacks like a duck, then it must be a duck." In Go, this translates to satisfying an interface by implementing its methods, regardless of the underlying concrete type.

Problem Description

Your task is to create a system that can operate on different types of "animals" using a common interface, demonstrating duck typing. You will define an interface that describes a common behavior for animals (e.g., making a sound), and then create several concrete animal types that implement this interface. Finally, you will write a function that accepts any type implementing this interface and calls the common behavior.

Key Requirements:

1. Define an Animal interface: This interface should have a method, for example, Speak() string, which returns the sound the animal makes.
2. Create Concrete Animal Types:
   • Dog: Implement Speak() to return "Woof!".
   • Cat: Implement Speak() to return "Meow!".
   • Cow: Implement Speak() to return "Moo!".
3. Implement a Generic Function: Create a function, say MakeAnimalSpeak(a Animal), that takes any type implementing the Animal interface and calls its Speak() method, printing the returned sound.
4. Demonstrate Duck Typing: In your main function, create instances of Dog, Cat, and Cow and pass them to MakeAnimalSpeak to show that it works polymorphically.

Expected Behavior:

When MakeAnimalSpeak is called with a Dog, it should print "Woof!". When called with a Cat, it should print "Meow!". When called with a Cow, it should print "Moo!".

Edge Cases to Consider:

• No Explicit Inheritance: Ensure that Dog, Cat, and Cow do not explicitly declare that they implement the Animal interface. Go's type system will infer this based on method signatures.

Examples

Example 1:

Input: A Dog instance
Output: Woof!
Explanation: The MakeAnimalSpeak function receives a Dog. Because Dog has a Speak() string method, it implicitly satisfies the Animal interface. The function calls Dog's Speak() method, which returns "Woof!".

Example 2:

Input: A Cat instance
Output: Meow!
Explanation: The MakeAnimalSpeak function receives a Cat. Because Cat has a Speak() string method, it implicitly satisfies the Animal interface. The function calls Cat's Speak() method, which returns "Meow!".

Example 3:

Input: A Cow instance
Output: Moo!
Explanation: The MakeAnimalSpeak function receives a Cow. Because Cow has a Speak() string method, it implicitly satisfies the Animal interface. The function calls Cow's Speak() method, which returns "Moo!".

Constraints

• The Speak() method must return a string.
• The output should be printed to standard output.
• The solution should be written entirely in Go.

Notes

• Think about how Go's interfaces work: they define a set of methods. Any type that implements all methods in the interface is considered to satisfy that interface.
• You do not need to explicitly use the implements keyword (as Go doesn't have one). The compiler will handle the satisfaction check.
• This exercise is about understanding Go's implicit interface satisfaction, which is the mechanism for achieving duck typing.