// as_ref和Borrow的區(qū)別 ?

// as_ref 是轉引用函數, 將具有所有權對象轉換成引用對象,
// 不改變被轉換對象的基礎上產生一個引用對象.

// as_ref 并不是所有類型都默認支持, 很多時候都需要自己去聲明.
// as_ref 是AsRef trait 的公共接口方法.
// 只有那些實現(xiàn)了 as_ref 公共接口方法的類型才能使用as_ref.
// 目前: Option, Box, Result 這三種類型默認提供支持as_ref.

// as_ref 和 Borrow 的區(qū)別是:
// 基礎數據類型引用:
//     Borrow 可以直接在 int, &str, String, vec, [], struct, enum 這種類型上直接指定&來引用.
//     as_ref 則不行, 它需要聲明泛型T: AsRef<int>, T: AsRef<str>, T: AsRef<struct name> 來支持.
// 嵌套數據類型引用: Some(&int) , Box(&int) ,
//     Borrow 必須在定義結構時聲明 Some<&int> , Box<&int> 才是引用.
//     as_ref 則直接可以在這些嵌套結構上使用as_ref.
// 引用的引用
//     Borrow 引用的引用的表現(xiàn)形式是:   &str -> &&str
//     as_ref 引用的引用的表現(xiàn)形式是:   &str -> &str


fn borrow_example() {
    let s = 1;
    let x = &s;                                                                // 直接引用
    println!("s:{}; x: {}", s, x);
}


fn borrow_nest_example() {

    fn hello(x: Option<&i32>) -> Option<&i32> {                                          // 指定Some<&i32>
        match x {
            Some(_item) => x,
            None => None
        }
    }

    let s = 1234;
    let z = hello(Some(&s));                                                   // 傳入之前要先把引用聲明好.
    println!("s: {};  z: {:?}", s, z);
}


#[allow(dead_code)]
#[allow(unused_variables)]
fn borrow_reference_to_reference() {
    let a: &str = "str";
    let b: &&str = &a;
}


fn as_ref_example() {

    // as_ref 在這種場景的使用上不如 borrow,
    // 這是因為這種寫法要求把所有權轉移進來.
    // 又不能把&str 返回回去, 因為生命周期會沖突.
    // 所以as_ref不建議在這種場景下使用.

    fn hello<T: AsRef<str>>(x: T) {
        let xx = x.as_ref();
        println!("xx: {}", xx);
    }
    let s = String::from("hello");
    hello(s);
}


fn as_ref_nest_example() {

    // as_ref 非常適合這種場景, 簡單快捷.

    fn hello(x: Option<i32>) -> Option<i32> {
        x.as_ref();                                                            // Option<i32>  to  Option<&i32> 很方便后續(xù)代碼的編寫.
        x
    }

    let s = 1234;
    let z = hello(Some(s));
    println!("s: {}; z: {:?}", s, z);
}


fn as_ref_reference_to_reference() {
    #[allow(dead_code)]
    #[allow(unused_variables)]
    fn hello<T: AsRef<str>>(x: T) {
        let y: &str = x.as_ref();
        let z: &str = y.as_ref();                   // 引用上再引用, 永遠只有一層引用.
    }

    let s = "hello";
    hello(s);
}


fn main() {
    borrow_example();
    borrow_nest_example();
    borrow_reference_to_reference();
    as_ref_example();
    as_ref_nest_example();
    as_ref_reference_to_reference();
}