advance/into-types/converse

[sunface]

https://course.rs/advance/into-types/converse.html

[LIPUU]

辛苦了 这里确实挺黑暗的

[overlords]

地狱

[qyWeiqy]

看了三遍，还是头大！！！

[siu91]

<'b, 'c> 这个 ' 是什么意思？

[sunface]

额，这里内容安排有点问题，这是生命周期，见后面的章节

[yuhao00]

我感觉至少要过一遍the book，不然直接上手这本肯定是一脸懵逼（我猜的

[cleanwk]

这节突然难度加大，待我先吃个饭晚上再看一遍，作者辛苦了，看得出来这本书写的真的用心。

[sunface]

这一章节起初是在进阶里面🤣 后面出于一些考虑移动到基础里，所以难度会比其他章节高一些

[caoxiemeihao]

@sunface 我飞哥手下留情先 🥺

[Jesse-666]

前面的内容还能接受 变形记有点受不了

[BiteFoo]

我第一反应是，要拍成电视里的变形计吗？😂

[zmh1994]

从上面代码可以看出，派生 Clone 能实现的根本是 T 实现了Clone特征：where T: Clone， 因此 Container 就没有实现 Clone 特征。

这句话有点不理解，看上面的代码不是已经实现了clone方法么，为啥说没有实现Clone特征？

[LucasIcarus]

宏自动派生的实现里加了 where T: Clone 作为限制条件. 所以下面实际的 clone 方法并没有被实现到任意 Container<T> 上.

后续自行实现(不使用#[derive(Clone)]) 的代码取消了 where T: Clone 限制.

[duanyuluo]

范型有很大的学习困难，是很容易把范型参数，包括生命周期都参数化去看待，所以认为：
impl Clone for Container where T: Clone
就是给Container实现了Clone特性。
但如果把范型参数都理解为：编译阶段把范型参数或具体类型参数，编译成不同版本的代码（特例化），就好理解了。比如：
Container
=>
Container_i32(Arc_i32)
所以，
impl Clone for Container
=>
impl Clone for Container_T //编译器特例化结果1

impl Clone for Container where T: Clone
=>
impl Clone for Container_T_with_Clone //编译器特例化结果2

两个struct的名字是不一样的，自然也就没有实现Clone了。因为，实现Clone的是Container_T_with_Clone而不是Container_T

[Endermanbugzjfc]

（单例化 monomorphisation）

[Cold-Stars]

where T: Clone也是类型的一部分
派生实现是有限定条件where T: Clone，所以对Container<T:Clone>实现了Clone特性，而没有对Container实现。
改成这样就可以fn clone_containers<T:Clone>(foo: &Container, bar: &Container)

[17998384]

第一个哥们解释的还是不够通透，应该说”宏自动派生的实现里加了 where T: Clone 作为限制条件，那么宏实际的 clone仅对T实现了Clone特征的才有效“，也就是说T为i32的时候，宏派生的clone才是有效果的，但T不确定类型时，也就相当于未实现clone，所以会自动用他的引用进行clone

[SifungLei]

难度突然上升

[zhimin-z]

impl<'a> Trait for &'a i32 {} 中的 'a是什么泛型啊？'a难道不可以使mut吗？

[zhimin-z]

是

[sunface]

生命周期～

[lijing-2008]

强制类型转换是真心没看懂啊，到底是谁强制转换到了谁，能不能再仔细讲讲。&i32 实现了特征 Trait， &mut i32 可以转换为 &i32，但是 &mut i32 依然无法作为 Trait 来使用。这句话怎么理解。

[sunface]

好的，建议收到～～谢谢哈

[dongzl]

哈哈好难！是因为太难了吗？练习题都没安排~

[sunface]

练习题有的，链接没放上去

[guopenghui]

根据我的实验，.运算符的匹配过程是这样的：
a.foo() 假设a: T

1. 首先，foo方法必须有一个self参数，才可能被匹配到
2. 尝试使用值方法调用，即找self参数类型与a相同的函数foo
   • 首先看如果a是引用类型(&或&mut，其他实现Deref的不算)，则先尝试调用<*T>::foo(a)
   • 尝试调用T::foo(a)
3. 尝试使用引用方法调用：给a加一个引用，比如&a:&T，尝试调用：
   • <*&T>::foo(&a)，即T::foo(&a)
   • <&T>::foo(&a)，即<&T>::foo(&a)
4. 尝试解引用方法调用。得到解引用类型，然后回到第1步开始尝试。直到找到匹配解引用类型或无法再解引用。
5. 尝试将定长类型转换为不定长类型来查找方法，如将[i32;3](数组)转为[i32](切片)，查找[i32]上的方法。
6. 找不到，报错。

关键的地方在于第2步的第(1)步，如果a的类型是&T，其实会先去尝试调用T的方法。 而如果a是其他实现了Deref的类型T，却不会先去调用*T的方法。

[Endermanbugzjfc]

感觉 rust 编译器这么慢
除了因为有程序宏外
大部分时间都花在这些规则检查上 😅

[xuexin]

为什么b的类型改成i32会导致下面无法判断e的类型？
fn main() {
let b: i16 = 1500; //为什么改成i32会导致下面无法判断e的类型

let b_: u8 = match b.try_into() {
    Ok(b1) => b1,
    Err(e) => {
        println!("{:?}", e.to_string());
        0
    }
};

}

[duanyuluo]

把编译器错误贴出来，没理解什么叫无法判断e的类型？

[alexniver]

[Neisseri]

确实有点😢

[authorixy]

画风突变

[zhaojuncw]

麻了捏 = =！

[lovefengruoqing]

难度忽然呈指数上升，看了两遍了，还是没理解透彻

[asd123wto]

突然难起来了，原地爆炸🥹

[Mammon-github]

喂，前方可是地狱啊

[0130w]

点操作符那一小节

若 T 不能被解引用，且 T 是一个定长类型(在编译器类型长度是已知的)

这里应该是笔误，编译期类型:D

[sunface]

好的。。已经修改，感谢

[zhangboqi]

这。。这。。这。。。还能学下去吗？

[Garker]

我听劝 这章节不学了

[sinopec]

二刷了，感觉这里居然能看懂了，记得之前看到这一块是一塌糊涂的，也不知道是作者改进表述了还是我真的开悟了。。。

[yxxuweb]

”首先也是最重要的，转换后创建一个任意类型的实例会造成无法想象的混乱，而且根本无法预测。不要把 3 转换成 bool 类型，就算你根本不会去使用该 bool 类型，也不要去这样转换。 “
莫名其妙的就出“不要把 3 转换成 bool 类型，就算你根本不会去使用该 bool 类型，也不要去这样转换。 ”很突兀。

[3517277]

我们先来推导一番。 首先通过值方法调用就不再可行，因为 T 没有实现 Clone 特征，也就无法调用 T 的 clone 方法。接着编译器尝试引用方法调用，此时 T 变成 &T，在这种情况下， clone 方法的签名如下： fn clone(&&T) -> &T，接着我们现在对 value 进行了引用。 编译器发现 &T 实现了 Clone 类型(所有的引用类型都可以被复制，因为其实就是复制一份地址)，因此可以推出 cloned 也是 &T 类型。

这里的值调用，因为value是&T类型，所以尝试值调用不是直接先从&T开始匹配吗？为什么这里说先看T呢？所谓的值调用，是看当前值的原始类型T？而不是先看当前值的实际类型&T吗？没看明白

[3517277]

我用了这个方法来测试：
'''rust
struct T{}

impl T{
fn clone(a:Self)->i32{
return 0;
}

fn do_stuff<T>(value: &T) {
    let cloned = value.clone();
}

}
'''

如果按上面说的，先调用T的值，那应该会调用我自定义的clone,应该会先返回i32类型吧？但实际上，cloned还是&T类型。

[17998384]

首先你的代码就是有问题的，定义了struct T并且在函数中又定义了泛型T，那么此时你的签名中&T实际是泛型而不是struct T，也就是说在函数中value.clone()和struct T的实现没有半毛钱关系；编译器基于&T去寻找clone方法还真找到了对应的实现，那就是标准库中的实现：

    #[stable(feature = "rust1", since = "1.0.0")]
    impl<T: ?Sized> Clone for &T {
        #[inline(always)]
        #[rustc_diagnostic_item = "noop_method_clone"]
        fn clone(&self) -> Self {
            *self
        }
    }

于是基于这个方法中的clone，因为是&self，所以基于&T那就是&&T，而返回值为*self那就是&T，所以最终结果为&T

[17998384]

而我上述发的代码对应的就是作者所说的”编译器发现 &T 实现了 Clone 类型.....“

[bettersemut]

有些复杂，感觉短暂的未来应该不会用到这么深的知识，以后有需要再来查阅

[cy-arctique]

点操作符小节那里: 从上面代码可以看出，派生 Clone 能实现的根本是 T 实现了Clone特征：where T: Clone， 因此 Container<T> 就没有实现 Clone 特征.

Container<i32> 也没有实现Clone trait 吗?

[17998384]

很明显实现了啊，所以&Container .clone()返回的就是Container啊

[gatsby0203]

如果之前是写C语言的，特别是写嵌入式裸机程序的。Transmutes里的操作简直是家常便饭，Rust主要还是想给用的人足够的控制力吧。

[Scott169]

1.75.0版Rust，TryInto 特征是预导入的，不需要use

[rahuahua]

fn do_stuff(value: &T) {
let cloned = value.clone();
}

[yuzheng14]

derive 宏派生的 Clone 实现代码

impl<T> Clone for Container<T> where T: Clone {
    fn clone(&self) -> Self {
        Self(Arc::clone(&self.0))
    }
}

这个是在哪里看的？我点进去 derive 和 Clone 都是注释的 /* compiler built-in */

[SoraRoseous]

点操作符那里，好像在引用方法调用和值方法调用之间还有一个::foo(&value)的调用

[SoraRoseous]

<T>::foo(&value)