basic/trait/generic

[giscus[bot]]

basic/trait/generic

https://course.rs/basic/trait/generic.html

[giveahug]

struct Point<T, U> {
x: T,
y: U,
}

impl<T, U> Point<T, U> {
fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
Point {
x: self.x,
y: other.y,
}
}
}

fn main() {
let p1 = Point { x: 5, y: 10.4 };
let p2 = Point { x: "Hello", y: 'c'};

let p3 = p1.mixup(p2);

println!("p3.x = {}, p3.y = {}", p3.x, p3.y);

}
//--------------------------------------------
p1.mixup(p2);
为啥mixup只传了一个参数

[sunface]

这是一个方法

[linbird]

p1.mixup(p2)可以理解为mixup(p1, p2)，这也是实际的调用方式，只不过后者的调用形式是编译器作用后的结果，即我们以 p1.mixup(p2)的形式通过编译器完成了函数调用mixup(p1, p2)，这和C++中是一样的

[edcijn]

self是由编译器传入的，和其它OOP里的self或this类似，区别只是显式或隐式传入。

[bluecode2017]

fn mixup<V, W>(self, other: Point<V, W>)

定义里就是一个参数 other

[codecow-s]

struct Point<T, U> {
x: T,
y: U,
}

impl<T, U> Point<T, U> {
// 实现 mixup，不要修改其它代码！
fn mixup<V,W>(self,other:Point<V,W>)->Point<T,W>{
Point{
x:self.x,
y:other.y,
}
}
}

fn main() {
let p1 = Point { x: 5, y: 10 };
let p2 = Point { x: "Hello", y: '中'};

let p3 = p1.mixup(p2);

assert_eq!(p3.x, 5);
assert_eq!(p3.y, '中');

}

为什么self改为&self不可以

[mumumusuc]

&self的话在函数内部使用的是不可变借用，使用self.x时编译器不能使用Move语义，再尝试使用Copy语义时T又没有Copy约束，所以编译器报错了。给T添加Copy约束即可解决

impl<T:Copy, U> Point<T, U> {
    fn mixup<V,W>(&self, other:Point<V,W>) -> 
Point<T,W> {
    ...
    }
}

[codecow-s]

谢谢哈，明白了，这部分的内容哪里有体现啊，感觉引用和借用那部分没看到哎

[mumumusuc]

self、&self区别的话函数那节有讲，Copy、Clone、Move在3.11.6还没完成

[BiteFoo]

刚好我看到这里的时候也在想这个问题，现在明白了一些

[wfk007]

我为啥觉得为了实现泛型 add 添加的 std::ops::Add<Output = T> 语法有点丑陋...

[Jly13]

泛型约束还有后置型的，形式更清晰一些，使用关键字where。

fn f1<T>(v:T) -> i32
  where T:Add { // 左边就是泛型约束了
  // ...
}

[bluecode2017]

可以写一行 表示T必须能做Add操作
fn f1(v:T) -> i32 where T:Add {
// ...
}

[ghost]

<Output=T> 是干什么的啊，这种语法以前没见过啊 /(ㄒoㄒ)/~~

[iostiny]

看到这里，我去搜了一下Where后置限制是谁先创造出来（Haskell）的。

目前我看到的语言有Swift/Rust，两种语言的使用方式类似，都是用于泛型类型遵从特定的协议/特性。

[352079]

<Output=T> 是干什么的啊，这种语法以前没见过啊 /(ㄒoㄒ)/~~
Output是关联类型实现trait的时候要通过type Output = 类型 ; 来指定Output的类型
因为是泛型函数所以需要为Add trait 通过 <Output = T>来指定Output的类型

[90designer]

Assert<{ core::mem::size_of::() < 768 }>: IsTrue,

这个 const泛型表达式，好丑，好难理解

[i-CNNN]

// 这一行，你拆开来看就觉得容易理解了：
Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue

// 1. core::mem::size_of::<T>() 这里返回一个类型占用内存的大小值
// 2. { core::mem::size_of::() < 768 } 这里是一个表达式，表达式返回一个bool值
// 类似于：
let x = {2 < 3};
// 3. <{ core::mem::size_of::<T>() < 768 }>: IsTrue 这句就是约束，这个内存大小一定要小于768（返回True）

[qianhaiyang]

great！！！

[sinopec]

c++泛型比这还丑，奇技淫巧太多了。。。。 这个至少第一次看都还能看的明白

[BiteFoo]

C++的看了一部分就开始脑瓜子疼了，可能是写这类范型代码不多导致的

[caoxiemeihao]

可与 TypeScript 的泛型一战否 🐶

[jinliming2]

any 警告
unknown 警告
as unknown as xxx 警告

[suica]

rust有常量表达式的约束，比ts的原生的泛型约束表达能力更加丰富一点

[endlesstravel]

看到这里给我整笑了
我也来一个 (xx as any) 警告
很多时候，我恨不得把 ts 函数输入的每个参数都校验一遍 😭

[endlesstravel]

看到这里给我整笑了 我也来一个 (xx as any) 警告 很多时候，我恨不得把 ts 函数输入的每个参数都校验一遍 😭

不过 ts 里边的泛型能整出一堆奇怪的玩意，配合代码校验提示，我有时还是挺佩服ts语言开发组的

[ztsweet]

• rustc : 1.61

fn main() {
    // println!("Hello, world!");
    let number_list = vec![34, 50, 25, 100, 65];

    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];

    let result = largest(&char_list);
    println!("The largest char is {}", result);
}
fn add<T: std::ops::Add<Output = T>>(a:T, b:T) -> T {
    a + b
}
fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
    let mut largest = list[0];
    for &item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

---

error[E0508]: cannot move out of type `[T]`, a non-copy slice
  --> main.rs:26:23
   |
26 |     let mut largest = list[0];
   |                       ^^^^^^^
   |                       |
   |                       cannot move out of here
   |                       move occurs because `list[_]` has type `T`, which does not implement the `Copy` trait
   |                       help: consider borrowing here: `&list[0]`

error[E0507]: cannot move out of a shared reference
  --> main.rs:28:18
   |
28 |     for &item in list.iter() {
   |         -----    ^^^^^^^^^^^
   |         ||
   |         |data moved here
   |         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
   |         help: consider removing the `&`: `item`

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0507, E0508.
For more information about an error, try `rustc --explain E0507`.

[i-CNNN]

只需要给T加上Copy的Trait就可以了.

largest<T: PartialOrd + Copy>

[yuhao00]

默认为move语义，不能通过引用把所有权拿走，除非你Copy一份，原来那一份你还是不能动。

[Pursue-LLL]

首先引用不允许转移所有权

list是切片引用类型 &[T]（引用的是数组某些元素的切片），但是list里的元素是T类型，而不是&T

对于 Copy 类型（如 i32、u32 等），索引操作会直接将值复制到新的变量中，因此不会引起所有权转移。
对于非 Copy 类型（如 String、Vec 等），如果你尝试通过索引操作将值赋给一个变量，Rust 会尝试移动该值，从而导致所有权转移。

但是引用又不允许所有权转移，所以报错，把T加上 Copy 约束，这个特征表示类型 T 的值是可以被“复制”的，而不是移动的。对于实现了 Copy 特征的类型，Rust 在赋值时会自动执行浅拷贝，而不是移动所有权。

[gongxufan]

吊打java泛型擦除

[ramonli]

这泛型，头大

[atidat]

largest方法跑不过

let mut largest = arr[0];
| ^^^^^^
| |
| cannot move out of here
| move occurs because arr[_] has type T, which does not implement the Copy trait
| help: consider borrowing here: &arr[0]

 for &item in arr.iter() {
|         -----    ^^^^^^^^^^
|         ||
|         |data moved here
|         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
|         help: consider removing the `&`: `item`

[Mysterious0o0]

官网是这么写的：

fn largest<T: std::cmp::PartialOrd> (list: &[T]) -> &T {
    let mut largest =  &list[0];
    for item in list.iter(){
        if item > largest {
            largest = item;
        }
    }
    largest
}

[liuhq]

要学会看错误，编译器已经告诉你了，是没有约束 Copy 的特征实现

|         |move occurs because `item` has type `T`, which does not implement the `Copy` trait
|         help: consider removing the `&`: `item`

[LXYan2333]

const泛型那里可以补充一下，N是可以直接在函数体里使用的。

fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
    println!("{}",N)
}

[Boooooom030]

struct Point {
x: T,
y: T,
}

impl Point {
fn x(&self) -> &T {
&self.x
}
}

fn main() {
let p = Point { x: 5, y: 10 };

println!("p.x = {}", p.x());

请问一下在x方法中，为什么最后需要返回&T类型呢？本地尝试了取消引用，提示cannot move out of self.x which is behind a shared reference，并且还说T没有copy特征，但是之前不是说了&self相当于self:&Self吗，这么说我直接self.x返回的不就应该是&T类型吗，难道说rust自动解引用了所以需要再引用一次吗？同时，为什么不能返回T类型呢

[yuhao00]

你的示例代码没有泛型参数的声明。

&self的确是self : &Self，但是self.x代表的是(&Self).x，意味着通过引用拿出其成员，属于move。所有权规则不允许通过引用拿走所有权，要么你Copy一份自己玩去，原来那一份你动不了。

[yuhao00]

另外，&self.x的类型是&T，就是那个成员x的引用。先处理self.x，&是最后的。

[Lincest]

可以直接运行的largest方法, 加入PartialOrd 和 Copy的trait

fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];

    for &item in list.iter() {
        {
            if item > largest {
                largest = item;
            }
        }
    }

    largest
}

[meimeitou]

Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue

这个真的是我现在就能看的代码吗？

上一步还是1+1=2，下一步就要解二元一次方程😂

[WenqingZong]

同感，Rust的语法实在是有点难懂。

[duanyuluo]

之前有个评论分析的很好，要用编译器的眼睛来审视代码 ：D

1. Assert: IsTrue
2. b => {true}
3. mem_size::() < 768 => true
   反着看，就容易理解了。

[duanyuluo]

我去，吃掉了《》符号
'''rust
Assert<{ core::mem::size_of::() < 768 }>: IsTrue
=>
const b: bool = core::mem::size_of::() < 768;
Assert: IsTrue
=>
let mem_of_T: usize = core::mem::size_of::();
const b: bool = mem_of_T < 768;
Assert: IsTrue
'''

[x931890193]

个人觉得、 习题还需要优化一下

[Tangjj1996]

刚从2.8.2 特征 Trait章节回来，感觉rust中好像没有泛型约束或者说叫特征约束了?

[xiandaoyan]

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
let mut largest = list[0];

for &item in list.iter() {
    if item > largest {
        largest = item;
    }
}

largest

}

这段代码在最新的rust 1.64版本上依然无法编译通过，请高手指点下呢，谢谢

[Boooooom030]

vsc报错很明显吧，在let mut largest = list[0]中 T没有约束copy特征

[endlesstravel]

所有权的问题？你是要从list中复制这个最大元素？还是从这个 list 中返回一个最大元素的引用之类的？
完善了下代码，如果不用clone的话，只能返回引用了

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
    if list.len() == 0 {
        panic!("error size")
    }
    let mut largest = &list[0];
    for item in list.iter() {
        if item > largest {
            largest = item;
        }
    }
    largest
}

[xiandaoyan]

感谢回复，我之前还没有学多特征约束，所以不知道后边可以+Copy，多谢@
Boooooom030

[xiandaoyan]

感谢回复，@endlesstravel你的方式返回引用没问题，多谢

[tiancheng92]

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> Option<&T> {
    if let Some(n) = list.get(0) {
        let mut largest = n;
        for item in list {
            if item > largest {
                largest = item;
            }
        }
        Some(largest)
    } else {
        None
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn largest_i32() {
        let list = vec![1, 2, 3, 4, 5];
        assert_eq!(largest(&list), Some(&5));
    }

    #[test]
    fn largest_str() {
        let list = vec!["1", "2", "3", "4", "5"];
        assert_eq!(largest(&list), Some(&"5"));
    }

    #[test]
    fn largest_string() {
        let list = vec![
            "1".to_string(),
            "2".to_string(),
            "3".to_string(),
            "4".to_string(),
            "5".to_string(),
        ];
        assert_eq!(largest(&list), Some(&"5".to_string()));
    }

    #[test]
    fn largest_none() {
        let list: Vec<&str> = vec![];
        assert_eq!(largest(&list), None);
    }
}

这样会不会更好点？

[ghost]

太牛了，这个单元测试秀到我了 👍

[ghost]

std::ops::Add<Output = T> 和 Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue, 都是什么啊，有谁能详细解释一下吗？/(ㄒoㄒ)/~~

[ghost]

自己摸索了一下，终于搞懂了，Rust 太强大了，以后想怎么约束就怎么约束：

#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

trait IsTrue {}
enum Assert<const N: bool> {}
impl IsTrue for Assert<true> {}

fn app<T, const N: usize>(arr: [T; N])
where
    Assert<{ N > 2 }>: IsTrue,  // N > 2 才能使用这个方法
{
    println!("{}", N);
    println!("YES");
}

fn main() {
    let arr: [i32; 3] = [1, 2, 3];
    app(arr);  // 可以

    let arr: [i32; 2] = [1, 2];
    app(arr);  // 不行
}

不过还是有很大局限性的，编译器提示说 const 泛型表达式 还不稳定，而且功能还没完全实现，比如下面这个就会报错提示在 const 泛型表达式 里调用函数这种复杂功能要未来才能实现：

fn app<T, const N: usize>(arr: [T; N])
where
    Assert<{ (1..=2).contains(&N) }>: IsTrue,
{
    println!("{}", N);
    println!("YES");
}

[TsGanT]

    a + b
}

[xianzheTM]

// 目前只能在nightly版本下使用
#![allow(incomplete_features)]
#![feature(generic_const_exprs)]

fn something<T>(val: T)
where
    Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,
    //       ^-----------------------------^ 这里是一个 const 表达式，换成其它的 const 表达式也可以
{
    //
}

fn main() {
    something([0u8; 0]); // ok
    something([0u8; 512]); // ok
    something([0u8; 1024]); // 编译错误，数组长度是1024字节，超过了768字节的参数长度限制
}

// ---

pub enum Assert<const CHECK: bool> {
    //
}

pub trait IsTrue {
    //
}

impl IsTrue for Assert<true> {
    //
}

这个例子一下给我干懵了，impl IsTrue for Assert<true>是啥？

fn something<T>(val: T)
where
    Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue

又是啥？怎么突然冒出来个where？

[TaelinSu]

let p2 = Point { x: "Hello", y: 'c'};

为什么我们定义结构体不允许字段类型为 &str，编译器提示需要生命周期标注。但泛型这里就可以

[TableBear]

const fn 催更

[madjxatw]

果然，牵涉到泛型，所有的语言都一样的丑陋，令人困惑的不一致的语法。

[cyx404]

fn largest<T: PartialOrd + Copy>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list.iter() {
        if item > largest {
            largest = &item;
        }
    }

    largest
}

为什么这段代码可以编译通过， largest = &item; item作为临时变量，下一次遍历会被销毁，它的引用怎么还能帮到的到largest

[TaelinSu]

我认为这里是发生了一次自动解引用，item 是 &T 类型，&item 本来是 &&T 类型，被隐式地进行了一次解引用，变成了 largest = item。换句话说，上面代码里 item 前的 & 毫无必要。

[zhishixiang]

电脑里有一个付费才能坐的斯拉夫大牢

[Wan-Yifei]

看完泛型，再显现之前编译器的各种检查，不得不说RUST的编译器终究承受了太多。

[DylanJinx]

其实这样也行，哈哈哈，可以不用const泛型：

fn display_array<T: std::fmt::Debug>(arr: T) {
  println!("{:?}", arr);
}
fn main() {
  let arr: [i32; 3] = [1, 2, 3];
  display_array(arr);

  let arr: [i32; 2] = [1, 2];
  display_array(arr);
}

[ArcMichael]

    fn add<T>(a: T, b: T) -> T {
        a + b
    }

|
14 | a + b
| - ^ - T
| |
| T
|
help: consider restricting type parameter T

    println!("add i8: {}", add(2i8, 3i8));
    println!("add i32: {}", add(20, 30));
    println!("add f64: {}", add(1.23, 1.23));



    fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
        a + b
    }

    println!("add i8: {}", add(2i8, 3i8));
    println!("add i32: {}", add(20, 30));
    println!("add f64: {}", add(1.23, 1.23));

[5angXR]

struct A;
struct S(A); 
struct SGen<T>(T);

这三个结构体是类单元结构体（unit-like structs）吗? 为什么还有()? 有点晕, 看不太懂..

[5angXR]

泛型的第一个练习题

[ix111]

第一个是单元结构体，第二个是元组结构体，第三个是泛型元组结构体

[bamuwe]

已经开始昏头了

[Hello-world150]

同感

[xbsheng]

坚持就是胜利~

[drakedoglife]

有点迷糊这里

在《Const 泛型》习题中，实例2给出了const泛型参数使用的三个条件：

• 一个单独的const泛型参数
• 一个字面量 (i.e. 整数, 布尔值或字符)
• 一个具体的 const 表达式( 表达式中不能包含任何 泛型参数)
  示例代码入下：

fn foo<const N: usize>() {}

fn bar<T, const M: usize>() {
    foo::<M>(); // ok: 符合第一种
    foo::<2021>(); // ok: 符合第二种
    foo::<{20 * 100 + 20 * 10 + 1}>(); // ok: 符合第三种
    
    foo::<{ M + 1 }>(); // error: 违背第三种，const 表达式中不能有泛型参数 M
    foo::<{ std::mem::size_of::<T>() }>(); // error: 泛型表达式包含了泛型参数 T
    
    let _: [u8; M]; // ok: 符合第一种
    let _: [u8; std::mem::size_of::<T>()]; // error: 泛型表达式包含了泛型参数 T
}

fn main() {}

问题就来了：代码中foo::<{ std::mem::size_of::<T>() }>(); // error: 泛型表达式包含了泛型参数 T"这一句和教程中的Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,这一句有什么区别吗？教程的例子不是也应该违背了条件3？

[TableBear]

可能是要开启nightly版本的generic_const_exprs特性才行，我复制这段代码近IDE也是会提示报错
generic parameters may not be used in const operations
type parameters may not be used in const expressions

[drakedoglife]

确实，开启后不再报错，也就是说这种写法在stable版本中仍然不支持。