too-many-lists/ok-stack/peek

[giscus[bot]]

too-many-lists/ok-stack/peek

https://course.rs/too-many-lists/ok-stack/peek.html

[smokeriu]

在定义peek时，为何rust不允许这种定义方式：

pub fn peek(&self) -> Option<&T> {
    self.head.map(|ref node| {
        &node.elem
    })
}

编译器的报错是cannot return value referencing function parameter。
我看了下Option::map的代码，发现：F: ~const FnOnce(T) -> U。
所以我理解的是：闭包其实接受的仍然是Box<...>，并在闭包内进行了借用？其实是下面的简写：

self.head.map(|node| {
      let ref ref_node = node;
      &ref_node.elem
})

想请教下这种理解是否正确。

[maolonglong]

应该不是闭包的问题，map 函数需要移走所有权，但是这里的 self.head 移不走

一定要写成 ref 的话可以这样：

pub fn peek(&self) -> Option<&T> {
    // self.head.map(|ref node| &node.elem)
    match self.head {
        Some(ref node) => Some(&node.elem),
        None => None,
    }
}

[ulic-youthlic]

即使使用了ref关键字，map依旧消费了方法的调用者。
可以参考这段代码：

let maybe_some_string = Some(String::from("Hello, World!"));
// `Option::map` takes self *by value*, consuming `maybe_some_string`
let maybe_some_len = maybe_some_string.map(|ref s| s.len());
assert_eq!(maybe_some_len, Some(13));
assert_eq!( maybe_some_string, Some(String::from( "Hello, World!")));

[ulic-youthlic]

观察map的实现代码：

    pub fn map<U, F>(self, f: F) -> Option<U>
    where
        F: FnOnce(T) -> U,
    {
        match self {
            Some(x) => Some(f(x)),
            None => None,
        }
    }

可以发现map先取得了self，然后再match，即使你匹配到一个ref node，所有权转移也已經发生

[tbontb-iaq]

pub fn peek(&self) -> Option<&T> {
    Some(&self.head.as_ref()?.elem)
}

[jeferwang]

Cool~!!!

[naosense]

声明中mut和闭包中的mut不一样，前者表示声明一个可变变量，后者表示模式匹配一个可变变量。除此之外，函数参数中也有mut的身影，冒号前通常修饰参数名，冒号后修饰引用。

[max201904]

其实 let 后面的 mut 也是模式匹配. 从 let 后面可以解构元组就可以看出来, let 后面也是模式, 只不过只能是不可驳模式(无需穷举全部可能).
如果要在 let 后面使用可驳模式, 就必须要使用 let-else 语句. 比如:
let Some(a) = b else {
panic!("error");
};

[sshelll]

pub fn peek() 中之所以要使用 as_ref，简单理解应该是这样？

1. map 方法会获得 self 的所有权
2. 不能返回函数内部变量的引用到外部
   例如：

#[allow(dead_code)]
struct Temp {
    num: i32,
}

#[allow(dead_code)]
fn ok_to_get_ref(temp: &Temp) -> &i32 {
    &temp.num
}

// 这段代码无法工作, 类似于跳过 as_ref 直接调用 map, 在 map 函数运行时获得了 self 本身的所有权
// self 内部的变量也就是 data owned by the current function
// 进一步, 如果返回 self 内部变量的引用则导致：returns a reference to data owned by the current function
fn not_ok_to_get_ref(temp: Temp) -> &i32 {
    &temp.num
}