Implement the Into Trait for Custom Types

Rust's standard library provides powerful traits that enable flexible type conversions. The Into trait is a prime example, allowing a type T to be converted into another type U by calling t.into(). This is incredibly useful for simplifying code and promoting idiomatic Rust. Your challenge is to implement this Into trait for your own custom data structures.

Problem Description

You are tasked with creating a custom struct in Rust and then implementing the Into trait for it, allowing instances of your struct to be converted into another specified type. This exercise will help you understand how traits work in Rust, particularly for defining conversions.

Key Requirements:

1. Define a custom struct, let's call it MyStruct. This struct should hold some basic data (e.g., a string and an integer).
2. Define another struct, let's call it TargetStruct, which will be the type that MyStruct can be converted into. TargetStruct should have fields that can reasonably accommodate the data from MyStruct.
3. Implement the Into<TargetStruct> trait for MyStruct.
4. The into() method should take ownership of the MyStruct instance and return a TargetStruct instance.

Expected Behavior:

When you have an instance of MyStruct, you should be able to call .into() on it, and it should seamlessly produce a TargetStruct instance with the corresponding data.

Edge Cases to Consider:

• Ensure that the conversion logic correctly handles all data within MyStruct.
• Consider what happens if MyStruct could potentially have invalid or missing data (though for this challenge, we'll assume valid data).

Examples

Example 1:

struct MyStruct {
    name: String,
    id: u32,
}

struct TargetStruct {
    description: String,
    identifier: u32,
}

// Implement Into<TargetStruct> for MyStruct here
// ...

fn main() {
    let my_data = MyStruct {
        name: String::from("Example Item"),
        id: 123,
    };

    let target_data: TargetStruct = my_data.into();

    println!("Target description: {}", target_data.description);
    println!("Target identifier: {}", target_data.identifier);
}

Output:

Target description: Example Item
Target identifier: 123

Explanation:

The my_data instance of MyStruct is converted into a TargetStruct using the .into() method. The name field from MyStruct is mapped to the description field of TargetStruct, and the id field is mapped to identifier.

Example 2:

struct Product {
    product_name: String,
    price_cents: u64,
}

struct DisplayItem {
    item_title: String,
    cost_in_dollars: f64,
}

// Implement Into<DisplayItem> for Product here
// ...

fn main() {
    let product = Product {
        product_name: String::from("Awesome Gadget"),
        price_cents: 9999, // $99.99
    };

    let display = product.into();

    println!("Item Title: {}", display.item_title);
    println!("Cost: ${:.2}", display.cost_in_dollars);
}

Output:

Item Title: Awesome Gadget
Cost: $99.99

Explanation:

Here, we demonstrate a conversion where the data type might change slightly (cents to dollars). The product_name is directly mapped to item_title. The price_cents is converted from an integer representing cents to a floating-point number representing dollars by dividing by 100.0.

Constraints

• Your MyStruct must contain at least two fields of different basic types (e.g., String, u32, bool).
• Your TargetStruct must have fields that can accommodate the data from MyStruct, potentially with some type coercion (like the cents to dollars example).
• The into() method must consume (take ownership of) the MyStruct instance.
• The implementation should be idiomatic Rust.

Notes

• Remember that Into<U> for T is often implemented alongside From<T> for U. The standard library automatically implements Into<U> for T if From<T> is implemented for U. However, for this exercise, you should directly implement Into<TargetStruct> for MyStruct.
• The into() method is part of the std::convert::Into trait. You'll need to use a impl Into<TargetStruct> for MyStruct block.
• The core of your implementation will be the fn into(self) -> TargetStruct function.
• Think about how you want to map the fields from your source struct to your target struct.