Implementing Lifetime Variance in Rust

Lifetime variance is a crucial concept in Rust for ensuring memory safety when dealing with references. This challenge will task you with implementing a generic function that accepts a reference to a string slice and returns a new String containing the reversed slice, while correctly handling lifetime variance to avoid compiler errors and ensure the returned String outlives the input slice. Understanding and applying lifetime variance is essential for writing robust and safe Rust code.

Problem Description

You are required to implement a function reverse_string_slice that takes a reference to a string slice (&str) and returns a new String containing the reversed slice. The function must be generic over the lifetime of the input slice, and the returned String must outlive the input slice. The challenge lies in correctly specifying the lifetimes to satisfy the borrow checker and ensure memory safety.

Key Requirements:

The function must accept a &str as input.
The function must return a String.
The returned String must contain the reversed characters of the input slice.
The lifetime of the returned String must be independent of the lifetime of the input &str. This is the core of the lifetime variance challenge.
The code must compile without warnings or errors.

Expected Behavior:

The function should correctly reverse the input string slice and return a new String containing the reversed characters. The returned String should remain valid even after the original input &str goes out of scope.

Edge Cases to Consider:

Empty string slice: Should return an empty String.
String slice with Unicode characters: The reversal should correctly handle Unicode characters (e.g., grapheme clusters).
Very long string slices: Consider potential performance implications, although optimization is not the primary focus of this challenge.

Examples

Example 1:

Input: "hello"
Output: "olleh"
Explanation: The input string "hello" is reversed to produce the output "olleh".

Example 2:

Input: ""
Output: ""
Explanation: An empty string slice results in an empty `String`.

Example 3:

Input: "你好世界"
Output: "界世好你"
Explanation: The Unicode string "你好世界" is correctly reversed to "界世好你".

Constraints

The input string slice can be of any length (including empty).
The input string slice can contain any valid UTF-8 characters.
The function should be reasonably efficient, but performance optimization is not the primary goal. A simple character-by-character reversal is acceptable.
The solution must be written in Rust.

Notes

Pay close attention to the lifetimes declared for the input slice and the returned String.
The compiler will provide helpful error messages if the lifetimes are not correctly specified. Read these messages carefully to understand the borrow checker's concerns.
Consider using the chars() method to iterate over the string slice as Unicode characters.
The goal is to demonstrate an understanding of lifetime variance, not to write the most performant string reversal function. Clarity and correctness are prioritized.
You will likely need to use a generic lifetime parameter to correctly express the relationship between the input and output.