Go Interface Design: Shape Area Calculator

This challenge focuses on understanding and implementing Go interfaces. You'll create a system to calculate the areas of different geometric shapes using a common interface, demonstrating polymorphism and loose coupling in Go. This is a fundamental concept for building flexible and maintainable Go applications.

Problem Description

Your task is to design and implement a Go program that can calculate the area of various geometric shapes. You will define an AreaCalculator interface that specifies a method for calculating area. Then, you will create concrete types for different shapes (e.g., Circle, Rectangle) that implement this interface. Finally, you will write a function that accepts a slice of AreaCalculator interface types and calculates the total area of all shapes in the slice.

Key Requirements:

1. Define an AreaCalculator Interface: This interface should have a single method, Area() float64, which returns the calculated area of the shape.
2. Implement Concrete Shape Types:
   • Circle: A struct representing a circle with a Radius (float64). Implement the Area() method for Circle. The formula for the area of a circle is π * radius². Use math.Pi.
   • Rectangle: A struct representing a rectangle with Width and Height (both float64). Implement the Area() method for Rectangle. The formula for the area of a rectangle is width * height.
3. Implement a Total Area Calculation Function: Create a function, CalculateTotalArea(shapes []AreaCalculator) float64, that iterates through the provided slice of AreaCalculator and sums up their individual areas.

Expected Behavior:

The program should correctly calculate and return the total area when given a collection of different shapes.

Edge Cases:

• Shapes with zero or negative dimensions: While mathematically possible for some shapes, for this problem, assume valid positive dimensions for all shapes. Your area calculation methods should produce non-negative results.
• Empty slice of shapes: The CalculateTotalArea function should correctly return 0.0 if the input slice is empty.

Examples

Example 1:

Input:
shapes := []AreaCalculator{
    Circle{Radius: 5.0},
    Rectangle{Width: 4.0, Height: 6.0},
}
Output: 117.53981633974483
Explanation: The area of the circle is π * 5² ≈ 78.5398. The area of the rectangle is 4 * 6 = 24. The total area is approximately 78.5398 + 24 = 102.5398. (Note: Actual calculation uses higher precision for Pi).

Example 2:

Input:
shapes := []AreaCalculator{
    Rectangle{Width: 10.0, Height: 2.0},
    Circle{Radius: 3.0},
    Rectangle{Width: 5.0, Height: 5.0},
}
Output: 103.26990816987243
Explanation: Rectangle 1 area: 10 * 2 = 20. Circle area: π * 3² ≈ 28.2743. Rectangle 2 area: 5 * 5 = 25. Total area: 20 + 28.2743 + 25 = 73.2743. (Error in example explanation - let's re-calculate for clarity)
Corrected Explanation for Example 2:
Rectangle 1 area: 10.0 * 2.0 = 20.0
Circle area: math.Pi * 3.0 * 3.0 ≈ 28.274333882308138
Rectangle 2 area: 5.0 * 5.0 = 25.0
Total area: 20.0 + 28.274333882308138 + 25.0 = 73.27433388230814
(The provided output in the example will be the accurate one, this explanation aims to clarify the calculation process.)

Example 3:

Input:
shapes := []AreaCalculator{}
Output: 0.0
Explanation: An empty slice of shapes should result in a total area of 0.0.

Constraints

• All dimensions (Radius, Width, Height) will be non-negative floating-point numbers (float64).
• Input shapes will be instances of Circle or Rectangle.
• The number of shapes in the input slice will not exceed 1000.
• The calculations should be performed using standard float64 precision.

Notes

• Remember to import the math package for math.Pi.
• The key to this problem is how you define the AreaCalculator interface and ensure your concrete types correctly satisfy it.
• Think about how Go's type system allows you to treat different concrete types uniformly through an interface.