Implementing Custom Type Coercion in Rust

Rust has built-in mechanisms for type coercion, but sometimes you need to define your own custom coercion rules between types. This challenge will guide you through creating a system that allows for the implicit conversion of one custom type to another under specific, user-defined circumstances. This is useful for creating more ergonomic APIs and abstracting over different data representations.

Problem Description

Your task is to implement a mechanism that allows for custom type coercion in Rust. You will define a trait that, when implemented for a type, enables it to be implicitly converted into another type. This conversion should not be automatic for all types but should be opt-in and controlled by the programmer.

Key Requirements:

1. Define a Trait: Create a new trait (e.g., CoercibleFrom<T>) that a type can implement to indicate it can be coerced from another type T.
2. Implement the Trait: For at least two distinct custom types, implement the CoercibleFrom<T> trait, defining how they can be converted from another specific type.
3. Demonstrate Coercion: Show how these custom coercions can be used in a scenario where an implicit conversion is desired. This typically involves function arguments or variable assignments where the compiler can infer the desired coercion.
4. Control and Explicit Conversion: Ensure that the coercion is not overly broad and that explicit conversion is still possible and the preferred way for non-standard conversions.

Expected Behavior:

When a function expects a certain type Y, and a variable of type X is provided, if Y implements CoercibleFrom<X>, the compiler should be able to implicitly convert X to Y.

Edge Cases to Consider:

• What happens if a type can be coerced from multiple other types?
• How do you prevent unintended coercions?
• How does this interact with existing Rust coercion rules?

Examples

Example 1: String-like Coercion

Let's say you have a UserIdentifier struct that can be created from a String.

// Hypothetical usage demonstrating the desired outcome
struct UserIdentifier(String);

// Assume CoercibleFrom<String> is implemented for UserIdentifier
// fn process_id(id: impl CoercibleInto<UserIdentifier>) { ... }
// process_id("user123".to_string()); // Implicit coercion should occur here

Example 2: Numerical Coercion with Specific Logic

Imagine a TemperatureCelsius struct that can be coerced from a f64 representing Fahrenheit, but with specific conversion logic.

// Hypothetical usage demonstrating the desired outcome
struct TemperatureCelsius(f64);

// Assume CoercibleFrom<f64> with Fahrenheit logic is implemented for TemperatureCelsius
// fn display_temp_celsius(temp: impl CoercibleInto<TemperatureCelsius>) { ... }
// let fahrenheit_value: f64 = 70.0;
// display_temp_celsius(fahrenheit_value); // Implicit coercion to Celsius should occur here

Constraints

• Your solution must be written entirely in Rust.
• You should define at least two custom structs that implement your coercion trait.
• The coercion mechanism should be designed to be safe and prevent panics where possible.
• Performance is not a primary concern, but the solution should be reasonably efficient.
• The coercion should leverage Rust's type system and traits effectively.

Notes

This challenge encourages you to think about how traits can be used to extend language features. Consider how you might represent the "target" type for coercion. While Rust's impl Trait syntax is a good way to receive coerced types, think about how you might signal that a type can be coerced into another. You might need to define a second trait to represent the "source" type for a coercion, or perhaps a single trait with generic parameters is sufficient. Good luck!