Rust JSON Serialization and Deserialization

This challenge focuses on building robust JSON handling capabilities in Rust. You will learn to convert Rust data structures into JSON strings (serialization) and parse JSON strings back into Rust data structures (deserialization). This is a fundamental skill for interacting with web APIs, configuration files, and inter-process communication.

Problem Description

Your task is to implement a Rust program that can serialize and deserialize data using the popular serde and serde_json crates. You will define a Rust struct representing a simple user profile and then perform the following operations:

1. Serialization: Convert an instance of your user profile struct into a JSON string.
2. Deserialization: Parse a given JSON string representing a user profile back into an instance of your Rust struct.

Key Requirements:

• Define a UserProfile struct with fields such as id (integer), username (string), email (string), and is_active (boolean).
• Implement serialization of a UserProfile instance to a JSON string.
• Implement deserialization of a JSON string into a UserProfile instance.
• Handle potential errors during both serialization and deserialization gracefully.

Expected Behavior:

• When serializing, the output JSON should accurately reflect the Rust struct's data. Field names in JSON should match struct field names (case-sensitive by default).
• When deserializing, the JSON data should be correctly mapped to the corresponding fields in the UserProfile struct.
• Your program should demonstrate successful serialization and deserialization using provided example inputs.

Edge Cases to Consider:

• What happens if a field is missing in the JSON during deserialization?
• What happens if a field in the JSON has a different data type than expected?
• What about optional fields in the UserProfile struct (e.g., a bio field that might be absent)?

Examples

Example 1: Serialization

Input: A UserProfile struct instance:

#[derive(Serialize, Deserialize, Debug)]
struct UserProfile {
    id: u32,
    username: String,
    email: String,
    is_active: bool,
}

let user = UserProfile {
    id: 101,
    username: String::from("johndoe"),
    email: String::from("john.doe@example.com"),
    is_active: true,
};

Output: A JSON string:

{"id":101,"username":"johndoe","email":"john.doe@example.com","is_active":true}

Explanation: The user struct is converted into its JSON string representation.

Example 2: Deserialization

Input: A JSON string:

{"id": 202, "username": "janedoe", "email": "jane.doe@example.com", "is_active": false}

Output: A UserProfile struct instance:

UserProfile {
    id: 202,
    username: String::from("janedoe"),
    email: String::from("jane.doe@example.com"),
    is_active: false,
}

Explanation: The JSON string is parsed into a UserProfile struct.

Example 3: Deserialization with Missing Field (Demonstrates Error Handling)

Input: A JSON string with a missing is_active field:

{"id": 303, "username": "testuser", "email": "test@example.com"}

Expected Behavior: Deserialization should fail, and your program should catch and report the error. (For this challenge, you can print an error message indicating the missing field.)

Constraints

• You must use the serde and serde_json crates.
• Your solution should be written in Rust.
• The solution should compile and run without errors.
• Error handling for deserialization should be demonstrated.

Notes

• Consider using #[derive(Serialize, Deserialize)] on your UserProfile struct to automatically implement the necessary traits.
• Explore how to handle optional fields using Option<T> in your struct definition.
• Familiarize yourself with serde_json::to_string for serialization and serde_json::from_str for deserialization.
• Think about how to represent JSON errors in Rust using Result.