Implementing Method Resolution in Rust

This challenge focuses on understanding and implementing Rust's powerful trait system, specifically how methods defined within traits are resolved and called on different types. You will create a system that allows various data structures to implement a common interface, demonstrating dynamic dispatch and static dispatch concepts.

Problem Description

You need to implement a mechanism for method resolution in Rust. This involves defining a trait with at least one method. Then, you'll create several distinct data structures that will implement this trait. The core of the challenge is to demonstrate how Rust's compiler resolves which specific implementation of the trait's method to call based on the type of the object.

Key Requirements:

• Define a Trait: Create a trait named Displayable with a single method display(&self) -> String. This method should return a string representation of the object.
• Implement the Trait: Implement the Displayable trait for at least three different struct types:
  • Book: Stores title: String and author: String.
  • Article: Stores title: String and publication: String.
  • BlogPost: Stores title: String and tags: Vec<String>.
• Method Resolution: Demonstrate how to call the display method on instances of these structs. Your solution should clearly show how Rust determines which display implementation to use.
• Generic Function: Create a generic function print_displayable<T: Displayable>(item: &T) that takes any type T that implements Displayable and prints its string representation using the display method. This will showcase static dispatch.
• Trait Object (Optional but Recommended): Create a function that can accept a collection of Displayable items that might be of different concrete types (e.g., using Box<dyn Displayable>). This will demonstrate dynamic dispatch.

Expected Behavior:

• Calling display directly on an instance of Book, Article, or BlogPost should invoke the correct implementation for that specific type.
• The print_displayable function should correctly call the display method for any Displayable type passed to it.
• If implementing trait objects, the collection should be able to hold and process items of different concrete types.

Edge Cases:

• Empty strings for title, author, publication, or tags.
• The BlogPost's tags vector being empty.

Examples

Example 1:

Input:
struct Book { title: String, author: String }
impl Displayable for Book { ... }
let book = Book { title: "The Rust Programming Language".to_string(), author: "Steve Klabnik and Carol Nichols".to_string() };
println!("{}", book.display());

Output:

Book: Title="The Rust Programming Language", Author="Steve Klabnik and Carol Nichols"

Explanation: The display method specific to the Book struct is called, formatting the book's details.

Example 2:

Input:
struct Article { title: String, publication: String }
impl Displayable for Article { ... }
let article = Article { title: "Rust's Memory Safety".to_string(), publication: "Tech Journal".to_string() };
println!("{}", article.display());

Output:

Article: Title="Rust's Memory Safety", Publication="Tech Journal"

Explanation: The display method specific to the Article struct is called.

Example 3:

Input:
struct BlogPost { title: String, tags: Vec<String> }
impl Displayable for BlogPost { ... }
let blog_post = BlogPost { title: "Understanding Traits".to_string(), tags: vec!["rust".to_string(), "traits".to_string()] };
println!("{}", blog_post.display());

Output:

BlogPost: Title="Understanding Traits", Tags=["rust", "traits"]

Explanation: The display method for BlogPost is called, including the list of tags.

Example 4 (Generic Function):

Input:
// ... implementations of Displayable for Book, Article, BlogPost
let book = Book { title: "Hello".to_string(), author: "Me".to_string() };
print_displayable(&book);

Output:

Book: Title="Hello", Author="Me"

Explanation: The generic function print_displayable correctly infers the type T as Book and calls its display method.

Constraints

• The Displayable trait must have exactly one method: display(&self) -> String.
• The Book, Article, and BlogPost structs must contain the fields specified in the problem description.
• The returned strings from display methods should be informative and clearly label the type of object and its fields.
• The solution should compile and run without errors.

Notes

This challenge is designed to help you understand how Rust's type system enables polymorphism through traits. Pay close attention to how you define the trait, implement it for different types, and then call the methods. Consider the difference between calling a method on a concrete type versus calling it through a trait object. This is fundamental to writing idiomatic and flexible Rust code.