Implementing Generic Functions with Trait Bounds

This challenge focuses on utilizing trait bounds in Rust to create generic functions that operate on different types while ensuring they possess specific characteristics. Trait bounds are a powerful mechanism for enforcing type constraints and enabling code reuse, a core concept in Rust's type system. Your task is to implement a function that calculates the average of a slice, constrained by a trait that defines a sum() method.

Problem Description

You need to implement a generic function calculate_average that takes a slice of a type T and returns the average as an f64. The type T must implement a trait called Summable which has a single method, sum(), that returns the sum of all elements of type T as an f64. The function should handle the case where the slice is empty by returning 0.0.

Key Requirements:

• Implement the Summable trait.
• Implement the calculate_average function using a generic type parameter T with a trait bound of Summable.
• Handle the empty slice case gracefully.
• Ensure the average is calculated correctly.

Expected Behavior:

The calculate_average function should take a slice of any type that implements the Summable trait and return the average of the elements as an f64. If the slice is empty, it should return 0.0.

Edge Cases to Consider:

• Empty slice: Should return 0.0.
• Slice containing only zeros: Should return 0.0.
• Large numbers: Consider potential overflow issues when summing the elements (though this is not a primary focus of the challenge).

Examples

Example 1:

Input: &[1, 2, 3, 4, 5]
Output: 3.0
Explanation: The sum of the elements is 15.0, and the average is 15.0 / 5.0 = 3.0.

Example 2:

Input: &[1.5, 2.5, 3.5]
Output: 2.5
Explanation: The sum of the elements is 7.5, and the average is 7.5 / 3.0 = 2.5.

Example 3:

Input: &[]
Output: 0.0
Explanation: The slice is empty, so the average is 0.0.

Constraints

• The Summable trait must be defined.
• The calculate_average function must be generic and use trait bounds.
• The function must handle empty slices correctly.
• The input slice can contain any number of elements (within reasonable memory limits).
• The return type of calculate_average must be f64.

Notes

• Think about how to define the Summable trait to be flexible enough to work with different numeric types.
• Consider using the len() method of the slice to determine if it's empty.
• The challenge focuses on demonstrating the use of trait bounds, not on extensive error handling or performance optimization. Focus on correctness and clarity.
• You can implement the Summable trait for i32, f64, and other common numeric types.