The signature of Path::strip_prefix is bizarrely overconstrained

[ExpHP]

pub fn strip_prefix<'a, P: ?Sized>(
    &'a self, 
    base: &'a P  // <===  ???  a reference?
) -> Result<&'a Path, StripPrefixError> 
where P: AsRef<Path>, 

This can clearly be generalized to

pub fn strip_prefix<'a, P>(
    &'a self, 
    base: P
) -> Result<&'a Path, StripPrefixError> 
where P: AsRef<Path>, 

Implementation.

(Note: Like many similar attempts to "generalize" function signatures, this is a potentially breaking change due to potential regressions in type inference)

[vitalyd]

This would be a breaking change since you can’t pass ?Sized types anymore (and that’s likely the reason for having it a reference to begin with). It’s debatable whether such impls exist for this case, but that would need to be answered first before considering this change IMO.

[ExpHP]

@vitalyd: You've said a similar thing before on users, but I still don't see the argument.

Looking back at the thread now I see you responded to my request for clarification:

vitalyd wrote:
The contrived example is if some code you don’t control gives you an R: Read + ?Sized based &mut R - say that’s all you have when they call into your code. Whether they should arrange things differently is a different question. But as I mentioned, that’s pretty contrived. Your assumption (fairly valid but not required) is that you’re starting with a place where you can form a &mut R yourself and pass that to a fn<R: Read>(r: R).

But even with this clarification I cannot see the issue. It seems to me I can call an fn(R) where R: Read just fine with a &mut R where R: Read + ?Sized.

fn foo<R: Read>(r: R) { }

fn bar<R: Read + ?Sized>(r: &mut R) { foo(r) }  // ok

Notice I did not form the &mut R myself.

[ExpHP]

Okay. Wait. I see something. It's an insanely subtle distinction, but it's there:

Only the &mut R form will implicitly reborrow.

fn foo1<R: Read + ?Sized>(r: &mut R) { }
fn foo2<R: Read>(r: R) { }

fn bar<R: Read + ?Sized>(r: &mut R) { foo1(r); foo1(r); } // okay
fn bar<R: Read + ?Sized>(r: &mut R) { foo2(r); foo2(r); } // Error: `r` was moved

...but this doesn't apply to strip_prefix, which takes an immutable borrow.

[vitalyd]

Right - for the Read conversation in that thread, reborrowing would be one concern (this nicety doesn't apply in a fully generic context).

Thinking about the strip_prefix case a bit more, I'm failing to come up with anything that will break. It seems like removing ?Sized could break some weird concoction, but I can't actually think of anything after all. The thing that would spook me though, as we've touched on in the forum, is type inference gone bad. Not sure about that one though.