generics-traits/advanced-traits

[giscus[bot]]

generics-traits/advanced-traits

Learning Rust By Practice, narrowing the gap between beginner and skilled-dev with challenging examples, exercises and projects.

https://zh.practice.rs/generics-traits/advanced-traits.html

[ylinfy]

`impl<T: Sub<Output = T>> Sub for Point {
type Output = Self;

fn sub(self, other: Self) -> Self::Output {
    Point {
        x: self.x - other.x,
        y: self.y - other.y,
    }
}

}`
请问下，这里Output = T和Point, 第一个T不是代表Point么，因为Output = T, 返回的是Point, 这样的话，那Point里面的T又怎么理解

[sunface]

T: Sub<Output = T> 仅仅是对 T 的特征约束，表示 T 这个类型要支持减法运算，和 Point 无关哈。

[lsmind]

T代表 Point中的T 而不是Point。

[Jesse-666]

最后一题 为么下面的结果还是11呢
理论上来讲 闭包的值被替换了15 那么15+1结果返回应该是16啊
let mut cacher = Cacher::new(|x| x+1);
assert_eq!(cacher.value(10), 11);
assert_eq!(cacher.value(15), 11);

[Jesse-666]

哦 我知道了。。第一次的结果存入了value

[worldstearly]

我居然看懂了。。。

[denganjia]

看了两遍才看懂

[lgdu]

了解了

[YiiMus]

的确，在第一次执行assert_eq!(cacher.value(10), 11);时，由于value为None，则会执行与None匹配的代码，进而将第一次的11存进value，当第二次执行assert_eq!(cacher.value(15), 11);时，由于先前的运行导致value中已经有值了，故而不再执行与None匹配的代码，转而执行与Some(v) 匹配的代码，然后输出其v的值，也就是11

[nasuf]

请问在第三题里面，为什么不使用完全限定语法也可以编译通过呢？

    assert_eq!(<Human as Pilot>::fly(&person), "This is your captain speaking.");
    assert_eq!(Pilot::fly(&person), "This is your captain speaking.");
    assert_eq!(<Human as Wizard>::fly(&person), "Up!");
    assert_eq!(Wizard::fly(&person), "Up!");

[nasuf]

哦这不是关联函数。通过类型匹配可以知道具体调用的是哪个方法

[zStruCat]

问个问题：第一题我的通过编译的解答是：

fn difference<C>(container: &C) -> <C as Contains>::A 
where 
C : Contains<A = <C as Contains>::B>,
C::A : std::ops::Sub<C::A, Output=C::A> {
    container.last() - container.first()
}

但我看参考答案里无论在trait中还是函数签名中都没有给出 std::ops::Sub 的约束，为什么参考答案也能编译通过？下面是参考答案的函数签名:

fn difference<C: Contains>(container: &C) -> i32

[jmu]

因为这个方法和Sub约束一点关系没有，就不应该写泛型。 出这个题的up主估计就是想证明， 不依赖其他约束的方法， 是没必要那么啰嗦的。

[panxy2013]

课程在讲关联类型, 和泛型是等价的. 好处是代码简介.
第一题是: 把泛型改写成关联类型

1. 调试通过的答案:
   trait Contains {
   type A;
   type B;
   fn contains(&self, _: &Self::A, _: &Self::B) -> bool;
   fn first(&self) -> i32;
   fn last(&self) -> i32;
   }

impl Contains for Container {
type A = i32;
type B = i32;

fn contains(&self, number_1: &i32, number_2: &i32) -> bool {
    (&self.0 == number_1) && (&self.1 == number_2)
}
// Grab the first number.
fn first(&self) -> i32 { self.0 }

// Grab the last number.
fn last(&self) -> i32 { self.1 }

}

fn difference(container: & impl Contains) -> i32 {
container.last() - container.first()
}

[makexiao113]

done 我想问一下 |x| x+1这算什么运算？

[QuarterHeaven]

闭包，在3.2节

[DylanJinx]

4.2

[makexiao113]

done，这章主要讲了泛型与特征的相关知识，目前只能说是有了初步得理解，之后还需通过练习进行更深入得理解

[stanhangzhou]

第四题没理解
为什么不需要 impl ops::Add<Bar，Output=Bar> for Foo 了？

另外减法的时候为什么必须顺序反过来？

// 修复错误，不要修改 `main` 中的代码!
use std::ops;

struct Foo;
struct Bar;

#[derive(PartialEq, Debug)]
struct FooBar;

#[derive(PartialEq, Debug)]
struct BarFoo;

// 下面的代码实现了自定义类型的相加： Foo + Bar = FooBar
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        FooBar
    }
}

impl ops::Sub<Bar> for Foo {
    type Output = BarFoo;

    fn sub(self, _rhs: Bar) -> BarFoo {
        BarFoo
    }
}

fn main() {
    // 不要修改下面代码
    // 你需要为 FooBar 派生一些特征来让代码工作
    assert_eq!(Foo + Bar, FooBar);
    assert_eq!(Foo - Bar, BarFoo);

    println!("Success!")
}

···rust
use std::ops;

struct Foo;
struct Bar;

#[derive(PartialEq, Debug)]
struct FooBar;

#[derive(PartialEq, Debug)]
struct BarFoo;

// The std::ops::Add trait is used to specify the functionality of +.
// Here, we make Add<Bar> - the trait for addition with a RHS of type Bar.
// The following block implements the operation: Foo + Bar = FooBar
impl ops::Add for Foo {
type Output = FooBar;

fn add(self, _rhs: Bar) -> FooBar {
    FooBar
}

}

impl ops::Sub for Foo {
type Output = BarFoo;

fn sub(self, _rhs: Bar) -> BarFoo {
    BarFoo
}

}

fn main() {
// DON'T modify the below code
// you need to derive some trait for FooBar to make it comparable
assert_eq!(Foo + Bar, FooBar);
assert_eq!(Foo - Bar, BarFoo);
}
···

[stanhangzhou]

查看了rust 官方文档 Sub特型，other 传入参数 是被减数。 我们本例的
···
impl ops::Sub for Bar {
fn sub(self, _rhs: Foo) -> BarFoo {
BarFoo
}
}
···
我理解顺序没问题啊！可是编译就反了！ 谁能帮忙解释一下。谢谢

[stanhangzhou]

哈哈， assert_eq!(Foo - Bar, BarFoo);！！！

[stanhangzhou]

要想反过来也可以，这样

// 修复错误，不要修改 `main` 中的代码!
use std::ops;

struct Foo;
struct Bar;

#[derive(PartialEq, Debug)]
struct FooBar;

#[derive(PartialEq, Debug)]
struct BarFoo;

// 下面的代码实现了自定义类型的相加： Foo + Bar = FooBar
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        FooBar
    }
}

impl ops::Sub<Foo> for Bar {
    type Output = BarFoo;

    fn sub(self, _rhs: Foo) -> BarFoo {
        BarFoo
    }
}

fn main() {
    // 不要修改下面代码
    // 你需要为 FooBar 派生一些特征来让代码工作
    assert_eq!(Foo + Bar, FooBar);
    assert_eq!(Foo - Bar, BarFoo);

    println!("Success!")
}

[stanhangzhou]

改成 assert_eq(Bar - Foo, BarFoo);

[wzg666666]

从main函数来看，第4题的主要目的是为Foo进行 +、- 等运算操作，并为结果进行断言：

fn main() {
    // 先进行Foo + Bar运算，然后进行断言
    assert_eq!(Foo + Bar, FooBar);
    // 先进行Foo - Bar运算，然后进行断言
    assert_eq!(Foo - Bar, BarFoo);
    println!("Success!")
}

可是由于Foo是我们自定义的struct，默认是没有实现Add和Sub特征的，故无法进行+-等运算，所以我们需要为Foo实现这些特征：

// 为Foo实现Add特征（题目里已经实现好了）
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        FooBar
    }
}
// 为Foo实现Sub特征
impl ops::Sub<Bar> for Foo {
    type Output = BarFoo;
    fn sub(self, _rhs: Bar) -> BarFoo {
        BarFoo
    }
}

至于楼主说的，把main函数的最后一行改成 assert_eq(Bar - Foo, BarFoo); 也可以运行，是因为代码里的impl ops::Sub<Foo> for Bar为Bar实现了Sub特征，当然就可以为Bar进行-运算了。

完整正确代码：

// 修复错误，不要修改 `main` 中的代码!
use std::ops;

struct Foo;
struct Bar;

// assert_eq! 的功能是为参数进行比较，若不相等则产生panic并用Debug模式打印参数值，所以需要为FooBar、BarFoo等struct派生PartialEq和Debug特征
#[derive(PartialEq, Debug)]
struct FooBar;
#[derive(PartialEq, Debug)]
struct BarFoo;

// 为Foo实现Add特征
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        FooBar
    }
}

// 修改前：为Bar实现Sub特征
// impl ops::Sub<Foo> for Bar {
//     type Output = BarFoo;
//     fn sub(self, _rhs: Foo) -> BarFoo {
//         BarFoo
//     }
// }

// 修改后：为Foo实现Sub特征
impl ops::Sub<Bar> for Foo {
    type Output = BarFoo;
    fn sub(self, _rhs: Bar) -> BarFoo {
        BarFoo
    }
}

fn main() {
    // 先进行Foo + Bar运算，然后进行断言
    assert_eq!(Foo + Bar, FooBar);
    // 先进行Foo - Bar运算，然后进行断言
    assert_eq!(Foo - Bar, BarFoo);

    println!("Success!")
}

[mattwhatsup]

感谢大佬的工作，最近看的rust资料，找了几个不同的教程，这个电子书是最有帮助的，也解答我之前遇到很多的问题。
讲的很清楚，尤其有练习题是非常贴心的，否则真的到自己写进行不下去。

[rolan36]

最后一题不理解QAQ

[rolan36]

(|x|x+1)需要怎么理解

[EXSPIRAVIT1104OFFICIAL]

是闭包（closure）
https://doc.rust-lang.org/std/ops/trait.Fn.html#calling-a-closure

[DongXiaoFat]

https://rustwiki.org/zh-CN/rust-by-example/fn/closures.html

[EXSPIRAVIT1104OFFICIAL]

Done.

[AliceThunder]

done

[AliceThunder]

done

[BruceChar]

这个评论跟习题对应不上还是小节里面的归总到一起了？另外 10.5的第四题 &self 签名，为什么不能String::from(self.name), 而是要self.name.clone()

[BruceChar]

这里self.name 为什么不是引用类型？

[BruceChar]

impl Programmer for CSStudent {
     fn fav_language(&self) -> String {
        // println!("type: {}", std::any::type_name_of_val(&self.language));
        // String::from(self.language)
        self.language.clone()
     }
}

[iscas-zac]

这个评论跟习题对应不上还是小节里面的归总到一起了？

是的，而且是generics、traits、advanced-traits这几篇习题归总到一起了

[EXSPIRAVIT1104OFFICIAL]

Done.

[Bruce012356]

mark

[DongXiaoFat]

最后一题，这么重要的闭包https://rustwiki.org/zh-CN/rust-by-example/fn/closures.html 竟然没介绍知道BiBo后最后一题还是很简单的，这TM就是匿名函数啊。

[Wan-Yifei]

闭包被放在课程后面了，我通读之后觉得Rust的教程是真难写，知识体系不是线性的。Rust的作者团队也存在多次返工重构，官方手册都存在举棋不定的情况。

[tohere]

最后一题不会的建议用 debug 的方式跑一下就明白嘞

[Altriaww]

Done

[QingXia-Ela]

怎么觉得最后的闭包反而是最简单的（（

[jareguo]

打卡成功，这一节值得把题都做了

[TableBear]

done

[zippermonkey]

关于第4题里面的Add 的含意，问了一下ChatGPT：

如果你在实现 Add trait 时没有指定类型参数，那么你需要在实现该 trait 时明确指定。比如 impl Add for MyType，这种情况下，你实现的是 MyType 与其自身的加法运算。

这里是一个例子：

use std::ops::Add;

struct MyType {
    value: i32,
}

impl Add for MyType {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        MyType {
            value: self.value + other.value,
        }
    }
}

在这个例子中，我们为 MyType 实现了 Add trait，但没有指定类型参数。这意味着我们定义了 MyType 与其自身的加法运算。add 方法接收两个 MyType 对象，然后返回一个新的 MyType 对象，其 value 是两个输入对象的 value 的和。

如果你想要定义 MyType 与其他类型的加法运算，你就需要在 Add trait 后面加上尖括号和那个类型，比如 Add<OtherType>。

[BokutoMan]

down

[BokutoMan]

down

[felipe300]

• done

[bling-yshs]

第8题的

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self {
            x,
            y,
        }
    }
}

似乎有点多余了，下面代码都没用到

[InnocentSmile]

学到这里 我已经云里雾里了 好难啊

[DylanJinx]

done~~~

[DylanJinx]

done~~~

[DylanJinx]

破案了，10.3与10.5这两个练习题的评论合在一起了