Implementing a String Representation for Custom Structs in Rust

This challenge focuses on implementing a custom string representation for a struct in Rust, mimicking the behavior of Python's repr() function. The goal is to provide a human-readable string representation of your struct that can be useful for debugging, logging, and other situations where a simple textual representation is needed. This is crucial for making your code more maintainable and easier to understand.

Problem Description

You are tasked with implementing a Repr trait and a repr function for a custom struct named MyStruct. MyStruct has three fields: x (i32), y (String), and z (bool).

The Repr trait should have a single method, repr(), which returns a String representing the struct's state. The repr function should take an instance of MyStruct as input and call the repr() method on it.

The string representation should follow this format: MyStruct { x: <x_value>, y: "<y_value>", z: <z_value> }. Replace <x_value>, <y_value>, and <z_value> with the actual values of the corresponding fields. Ensure the string is properly formatted and readable.

Key Requirements:

• Define a Repr trait with a repr() method that returns a String.
• Implement the Repr trait for the MyStruct struct.
• Create a repr function that takes a MyStruct instance and returns its string representation.
• The string representation must adhere to the specified format.

Expected Behavior:

The repr function should return a string that accurately reflects the state of the MyStruct instance. The string should be well-formatted and easy to understand.

Edge Cases to Consider:

• Empty y field (String).
• Negative values for x (i32).
• Boolean values true and false for z.

Examples

Example 1:

Input: MyStruct { x: 10, y: "hello".to_string(), z: true }
Output: MyStruct { x: 10, y: "hello", z: true }
Explanation: The function constructs a string representation of the struct with the given values.

Example 2:

Input: MyStruct { x: -5, y: "".to_string(), z: false }
Output: MyStruct { x: -5, y: "", z: false }
Explanation: Handles negative numbers and empty strings correctly.

Example 3:

Input: MyStruct { x: 0, y: "world!".to_string(), z: true }
Output: MyStruct { x: 0, y: "world!", z: true }
Explanation: Demonstrates handling of zero and a string with special characters.

Constraints

• The x field will be an i32.
• The y field will be a String.
• The z field will be a bool.
• The output string must be a valid UTF-8 string.
• The solution should be efficient and avoid unnecessary string allocations.

Notes

• Consider using Rust's string formatting capabilities (e.g., format!) to construct the string representation.
• The goal is to create a clear and concise representation of the struct's state.
• Think about how to handle different data types within the struct to ensure a consistent and readable output.
• This exercise is about understanding how to customize string representations for your own data structures in Rust.