Answer.

Historically, one of the principles of Rust was to ensure type safety and the absence of implicit conversions that lead to runtime errors. However, for code convenience, partial automatic conversions are implemented through deref coercion and From/Into traits to simplify working with references, smart pointers, and to allow universal APIs.

The problem arises when automatic conversions can cause confusion, for instance, when passing a &String where a &str is expected. A hidden Deref::deref is called, and sometimes unforeseen consequences occur (for example, when changing the type of passed parameters). There is also the question of direct and explicit casting through as.

Solution: Rust implements strict deref-coercion rules for smart pointers (Box, Rc, Arc) and strings (&String to &str, &Vec to &slice) at the compiler level. For explicit conversions, the traits From, Into, TryFrom, TryInto, as for basic casts are provided. Static typing and limiting implicit conversions help to avoid errors.

Code example:

fn print_text(text: &str) {
    println!("{}", text);
}

let s = String::from("Hello!");
print_text(&s); // s: String, &s: &String, auto-conversion to &str

Key features:

Deref coercion occurs when a function/method with a reference type is called.
Explicit type conversions via From/Into traits for safe conversions.
as is suitable exclusively for primitive types, otherwise, incorrect behavior may occur.

Trick Questions.

Does deref coercion work for custom types if Deref is implemented manually?

Yes, if you implement the Deref trait for your type, the compiler will be able to automatically convert, for example, your wrapper into the target type within the function signature expecting the corresponding reference.

Can deref coercion occur for values, not references?

No, automatic dereferencing occurs only when passing references, and only when the type implements Deref.

What are the limitations of type casting through as when working with numbers and enums?

as does not guarantee safety: converting between numeric types can cause overflow or data loss, and for enums, it can lead to non-semantic values (for example, to an incorrect enum variant).

Typical Mistakes and Anti-Patterns

Expecting implicit conversion where Rust does not perform it: string concatenation via + without casting to &str.
Using as between incompatible types (for example, casting &str to &String directly is not possible).
Explicit cloning when passing references, where deref coercion is sufficient.

Real-life Example

Negative Case

A novice writes a function that takes &String and cannot use &str directly, always doing text.to_string() from the string. This is wasteful in terms of memory and performance.

Pros:

Clear understanding that the function works with String.

Cons:

Unnecessary allocations, loss of API universality, maintenance complexity.

Positive Case

The function takes an argument of type &str, allowing it to be called with any type that supports dereferencing or coercion: &str, &String, string literals. No unnecessary allocations are required.