libs: generalize as_ref/by_ref adapters to use BorrowFrom

[aturon]

It is a pain to go from Option<String> to Option<&str>:

opt.as_ref().map(|s| s.as_slice())

This could be improved by integrating the new BorrowFrom infrastructure, generalizing the signature of as_ref from

fn as_ref(&self) -> Option<&T>

to

fn as_ref<U=T>(&self) -> Option<&U> where U: BorrowFrom<T>

However, to avoid a regression in type inference for types that can be borrowed in multiple ways, we need default type parameters on methods (as above). See rust-lang/rfcs#213

[aturon]

cc @alexcrichton @nikomatsakis

[aturon]

cc @japaric, you may be interested in this as well.

[ftxqxd]

Does this apply to the by_ref adapters on Iterator, Reader, and Writer, as the title suggests? I don’t really see how those methods are related.

[apasel422]

This is now possible, though it requires the default_type_parameter_fallback feature gate:

#![feature(default_type_parameter_fallback)]

use Option::*;
use std::borrow::Borrow;

pub enum Option<T> {
    None,
    Some(T),
}

impl<T> Option<T> {
    pub fn as_ref<U: ?Sized = T>(&self) -> Option<&U> where T: Borrow<U> {
        match *self {
            None => None,
            Some(ref t) => Some(t.borrow()),
        }
    }
}

#[test]
fn test() {
    let opt = Some("foo".to_string());
    let _r1 = opt.as_ref(); // falls back to `Option<&String>`
    let _r2 = opt.as_ref::<str>();
}

[aidanhs]

On the topic of Option<String> to Option<&str>, one alternative possibility is given in http://stackoverflow.com/questions/31233938/converting-from-optionstring-to-optionstr

use std::ops::Deref;

trait OptionDeref<T: Deref> {
    fn as_deref(&self) -> Option<&T::Target>;
}

impl<T: Deref> OptionDeref<T> for Option<T> {
    fn as_deref(&self) -> Option<&T::Target> {
        self.as_ref().map(Deref::deref)
    }
}

[aturon]

Needs RFC (language change)