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。

[zhulin4k]

你可以理解为用实现了 Sub 的 T 去帮助 Point 实现 Sub

[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)需要怎么理解

[haochen-zeng]

是闭包（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

[haochen-zeng]

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这几篇习题归总到一起了

[haochen-zeng]

Done.

[Bruce012356]

mark

[DylanJinx]

done~~~

[DylanJinx]

done~~~

[DylanJinx]

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

[Howe829]

第11题 new的参数 (|x| x+1)是一个闭包，类似于python的lambda函数

[anousonefs]

ແລ້ວໆ

[jeepli]

哎卧槽，把sheep看成了sleep，还以为大神有裸睡习惯。。。

[TDAkory]

mark finished

[TDAkory]

mark finished

[chenchong22]

Mark

[yomanthunder]

This exercise is quite tough could not do most of them , i need revisit again after some more practice of rust

[ospdz]

第4题是不是有点歧义，按题目要求应该是只加派生注解，不改代码。
impl ops::Sub for Bar
答案是改了这一行的，我就说怎么想不出来有什么注解能达到要求的

[zzzk1]

day5

[bansal-harsh-2504]

Done ✅
Day 9

[gastrodia]

目前来说最难的一节，我竟然全部做对了

[gastrodia]

第一题

struct Container(i32, i32);

// 使用关联类型实现重新实现以下特征
// trait Contains {
//    type A;
//    type B;
/*
trait Contains<A, B> {
    fn contains(&self, _: &A, _: &B) -> bool;
    fn first(&self) -> i32;
    fn last(&self) -> i32;
}
*/
trait Contains {
    type A;
    type B;
    fn contains(&self, _: &Self::A, _: &Self::B) -> bool;
    fn first(&self) -> i32;
    fn last(&self) -> i32;
}


/*impl Contains<i32, i32> for Container {
    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 }
}*/

impl Contains for Container {
    type A = i32;
    type B = i32;
    fn contains(&self, number_1: &Self::A, number_2: &Self::B) -> 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<A, B, C: Contains<A, B>>(container: &C) -> i32 {
    container.last() - container.first()
}*/

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

fn main() {
    let number_1 = 3;
    let number_2 = 10;

    let container = Container(number_1, number_2);

    println!("Does container contain {} and {}: {}",
             &number_1, &number_2,
             container.contains(&number_1, &number_2));
    println!("First number: {}", container.first());
    println!("Last number: {}", container.last());

    println!("The difference is: {}", difference(&container));
}

---

第二题

impl Sub for Point<i32> {
    type Output = Self;

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

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

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

impl Sub<Point<i32>> for Point<i32> {
    type Output = Self;

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

---

第三题

fn main() {
    let person = Human;

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

    assert_eq!(person.fly(), "*waving arms furiously*");

    println!("Success!")
}

---

第四题

trait Person {
    fn name(&self) -> String;
}

// Person 是 Student 的 supertrait .
// 实现 Student 需要同时实现 Person.
trait Student: Person {
    fn university(&self) -> String;
}

trait Programmer {
    fn fav_language(&self) -> String;
}

// CompSciStudent (computer science student) 是 Programmer
// 和 Student 的 subtrait. 实现 CompSciStudent 需要先实现这两个 supertraits.
trait CompSciStudent: Programmer + Student {
    fn git_username(&self) -> String;
}

fn comp_sci_student_greeting(student: &dyn CompSciStudent) -> String {
    format!(
        "My name is {} and I attend {}. My favorite language is {}. My Git username is {}",
        student.name(),
        student.university(),
        student.fav_language(),
        student.git_username()
    )
}

struct CSStudent {
    name: String,
    university: String,
    fav_language: String,
    git_username: String
}

impl Programmer for CSStudent {
    fn fav_language(&self) -> String {
        self.fav_language.clone()
    }
}

impl Student for CSStudent {
    fn university(&self) -> String {
        self.university.clone()
    }
}

impl Person for CSStudent {
    fn name(&self) -> String {
        self.name.clone()
    }
}

// 为 CSStudent 实现所需的特征
impl CompSciStudent for CSStudent {
    fn git_username(&self) -> String {
        self.git_username.clone()
    }
}

fn main() {
    let student = CSStudent {
        name: "Sunfei".to_string(),
        university: "XXX".to_string(),
        fav_language: "Rust".to_string(),
        git_username: "sunface".to_string()
    };

    // 填空
    println!("{}", comp_sci_student_greeting(&student));
}

---

第五题

use std::fmt;

// 定义一个 newtype `Pretty`

struct Pretty(String);

impl fmt::Display for Pretty {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "\"{}\"", self.0.clone() + ", world")
    }
}

fn main() {
    let w = Pretty("hello".to_string());
    println!("w = {}", w);
}