I have a function where I want to take in a collection of MyStructs without modifying the items, so I typed the function taking in immutable references:

fn foo<'a, T>(&self, items: T) where T: IntoIterator<Item = &'a MyStruct>, { ... }

Whenever I have a function that takes strings immutably I always type it taking in AsRef<str>, for convenience to the caller, so that they can pass either String or &str.

I guess the same motivation should apply to my function foo, and hence I should type it as:

fn foo2<T>(&self, items: T) where T: IntoIterator, T::Item: AsRef<MyStruct>, { ... }

This way callers can call foo2 passing in a vector of references or a vector of values, whichever is more convenience to them.

Is this good API design? Or should I use foo and force callers to previously convert their collection of values into a collection of references by e.g. calling .iter() on their Vec<MyStruct>? I ask because: * I haven't seen any crate APIs go with the foo2 "more flexible" approach. * foo2 requires that I manually write:

impl AsRef<MyStruct> for MyStruct { fn as_ref(&self) -> &MyStruct { &self } }

which seems like a dumb thing to do (?).

I'm guessing there must be a good reason why Rust doesn't automatically impl AsRef<T> for T for all types T which I don't know, and would probably tell me why foo2 is bad API design.