Implement a Generic map Function in Rust

This challenge asks you to implement a generic map function in Rust that mimics the behavior of the map operation found in many functional programming languages and Rust's own iterator adapters. The map function is a fundamental tool for transforming collections by applying a given function to each element.

Problem Description

You need to implement a function named map that takes two arguments:

1. A slice of elements of type T.
2. A closure (or function pointer) that accepts an element of type T and returns an element of type U.

The map function should return a Vec containing the results of applying the closure to each element in the input slice, in the same order.

Key Requirements:

• The function must be generic over the input element type T and the output element type U.
• The function must accept a slice &[T] as input.
• The closure must be able to take ownership of T (or a reference to it, depending on the closure signature you choose, but for simplicity, let's aim for taking ownership or a reference that can be coerced). For this challenge, it's recommended to accept a closure that takes T by value.
• The function should return a Vec<U>.
• The order of elements in the output Vec must be the same as their order in the input slice.

Expected Behavior: If the input slice is empty, the function should return an empty Vec.

Edge Cases to Consider:

• An empty input slice.
• Slices containing various data types (integers, strings, custom structs).
• Closures that transform elements to a different type.

Examples

Example 1:

Input: slice = [1, 2, 3], closure = |x| x * 2
Output: [2, 4, 6]
Explanation: The closure `|x| x * 2` is applied to each element: 1*2=2, 2*2=4, 3*2=6.

Example 2:

Input: slice = ["hello", "world"], closure = |s| s.len()
Output: [5, 5]
Explanation: The closure `|s| s.len()` calculates the length of each string: "hello".len()=5, "world".len()=5.

Example 3:

Input: slice = [], closure = |x| x + 1
Output: []
Explanation: An empty input slice results in an empty output vector.

Constraints

• The input slice can contain any type T for which the closure can be applied.
• The closure must return a type U.
• The function should not modify the original input slice.
• Performance: The implementation should be reasonably efficient, avoiding unnecessary copying or allocations beyond what is required for the output Vec.

Notes

• Think about how to make your function generic. What traits might be relevant?
• Consider the signature of the closure. What type should it accept? T, &T, or &mut T? For this problem, accepting a closure that takes T by value is a good starting point, but you might need to consider how to get values out of the slice to pass them to the closure.
• You will need to create a new Vec to store the results.
• You might find the into_iter() or iter() methods on slices helpful.