generics-traits/trait-object #220

2022-04-21T03:13:43Z

giscus[bot]
bot Apr 21, 2022

generics-traits/trait-object

Learn Rust with Example, Exercise and real Practice, written with ❤️ by https://course.rs team

https://practice.rs/generics-traits/trait-object.html

lijing-2008 · 2022-05-03T15:32:13Z

lijing-2008
May 3, 2022 — with giscus

fn hatch_a_bird(num: u8) -> Box<dyn Bird>{
    match num {
        1 => Box::new(Swan),
        _ => Box::new(Duck),
    }
}

0 replies

lijing-2008 · 2022-05-03T15:37:14Z

lijing-2008
May 3, 2022 — with giscus

    let birds:[Box<dyn Bird>; 2] = [Box::new(Duck), Box::new(Swan)];

2 replies

s724123 Oct 20, 2022 — with giscus

出现了报错

the trait Iterator is not implemented for [Box<dyn Bird>; 2]

后来写成了

let birds: &[Box<dyn Bird>;2] = &[Box::new(Duck {}), Box::new(Swan {})];

但是不明所以

doooooit Jan 9, 2024 — with giscus

可以使用 Vec：

let birds: Vec<Box<dyn Bird>> = vec![Box::new(Duck), Box::new(Swan)];

lijing-2008 · 2022-05-03T15:50:43Z

lijing-2008
May 3, 2022 — with giscus

// 通过泛型实现以下函数
fn static_dispatch<T>(param: T)
    where T:Foo
{
    println!("{}", param.method());
}

// 通过特征对象实现以下函数
fn dynamic_dispatch(param:&dyn Foo){
    println!("{}", param.method());
}

0 replies

klenkiven · 2022-05-22T14:33:24Z

klenkiven
May 22, 2022 — with giscus

第四题也可以通过 impl 语法实现，不过不知道是不是合乎规矩的

fn static_dispatch(foo: impl Foo) {
    foo.method();
}

2 replies

jesHrz Jun 11, 2022 — with giscus

这俩应该是等价的吧？

fn static_dispatch<T: Foo>(foo: T) {
    foo.method();
}

labuladong Aug 16, 2022 — with giscus

是一样的，之前讲了 impl 就是泛型的语法糖

makexiao113 · 2022-07-10T07:47:46Z

makexiao113
Jul 10, 2022 — with giscus

done，本节主要讲了特征对象的相关知识，其中使用到了dyn关键字，这个dyn关键字我觉得和rust最初的设计理念并不相符，因为rust本身是想要在编译阶段就确定所有参数的类型的，这样程序的运行时性能才会最高，dyn动态分发就破坏了这一理念，拙见，轻喷

1 reply

sunface Jul 11, 2022
Maintainer

毕竟还要考虑工程性 🤣

DrEden33773 · 2022-09-06T16:20:39Z

DrEden33773
Sep 6, 2022 — with giscus

done！这里的第六题有一个新的思路，使用 泛型特征(Generic Traits) ，代码如下:

trait MyTrait<T> {
    fn f(&self) -> T;
}

impl MyTrait<u32> for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait<String> for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function<T: MyTrait<T>> (x: Box<dyn MyTrait<T>>) -> T { // could be discarded
    x.f()
}

fn my_function_2<T: MyTrait<T>> (x: Box<T>) -> T { // could be discarded
    x.f()
}

fn main() {
    my_function(
        Box::new(13_u32)
    );
    my_function(
        Box::new( String::from("abc") )
    );
    my_function_2(
        Box::new(13_u32)
    );
    my_function_2(
        Box::new( String::from("abc") )
    );

    println!("Success!")
}

2 replies

wangshankun Nov 15, 2022 — with giscus

特征对象的特征对象，要求方法没有任何泛型参数；
fn f(&self) -> T; 合理？

lsmind Dec 12, 2022 — with giscus

这里的泛型参数是trait的，而不是方法的。但由于用到了trait绑定，两个my_function其实都是静态分发的。

DrEden33773 · 2022-09-06T16:42:30Z

DrEden33773
Sep 6, 2022 — with giscus

再更新一个6的思路

trait MyTrait {
    type Output;
    fn f(&self) -> Self::Output;
}

impl MyTrait for u32 {
    type Output = u32;
    fn f(&self) -> Self::Output { 42 }
}

impl MyTrait for String {
    type Output = String;
    fn f(&self) -> Self::Output { self.clone() }
}

fn my_function<T: MyTrait<Output = T>> (
    x: Box<dyn MyTrait<Output = T>>
) -> T { // could be discarded
    x.f()
}

fn my_function_2<T: MyTrait<Output = T>> (
    x: Box<T>
) -> T { // could be discarded
    x.f()
}

fn main() {
    my_function(
        Box::new(13_u32)
    );
    my_function(
        Box::new( String::from("abc") )
    );
    my_function_2(
        Box::new(13_u32)
    );
    my_function_2(
        Box::new( String::from("abc") )
    );

    println!("Success!")
}

2 replies

Tlntin Feb 6, 2023 — with giscus

哈哈，刚好我想到的两个思路就是这两个。题解的那两个思路反而没想那边去。

DrEden33773 Feb 7, 2023

哈哈

wangshankun · 2022-11-15T12:38:02Z

wangshankun
Nov 15, 2022 — with giscus

来个花活，虽然编译过去了，但是应该属于静态的

// 通过特征对象实现以下函数,
fn dynamic_dispatch(a:&impl Foo) {
a.method();
}

0 replies

EXSPIRAVIT1104OFFICIAL · 2022-11-18T08:57:09Z

EXSPIRAVIT1104OFFICIAL
Nov 18, 2022 — with giscus

Done.

0 replies

AliceThunder · 2022-11-27T09:14:23Z

AliceThunder
Nov 27, 2022 — with giscus

done

1 reply

worldstearly Dec 7, 2022 — with giscus

trait MyTrait {
    fn f(&self);
}

impl MyTrait for u32 {
    fn f(&self) {}
}

impl MyTrait for String {
    fn f(&self) {}
}

fn my_function(x: Box<dyn MyTrait>) {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

Bruce012356 · 2023-01-04T03:25:50Z

Bruce012356
Jan 4, 2023 — with giscus

mark

0 replies

790228724 · 2023-01-29T07:10:44Z

790228724
Jan 29, 2023 — with giscus

第二题可以根据特征对象的学习内容写成

let birds : Vec<Box> = vec![Box::new(Duck{}),Box::new(Swan{})];;

1 reply

790228724 Jan 29, 2023 — with giscus

let birds : Vec<Box<dyn Bird>> = vec![Box::new(Duck{}),Box::new(Swan{})];;

pluschen-stack · 2023-03-01T18:06:22Z

pluschen-stack
Mar 1, 2023 — with giscus

trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function(x: impl MyTrait) -> impl MyTrait  {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));
}

第五题的这个为什么可以通过啊，my_function()不是返回了两种不同的类型（u32和String）吗

7 replies

Nixicodo Mar 2, 2023 — with giscus

比如我写成这样，我给MyTrait多增加了一个固定返回u32的函数。然后在my_function的函数体里尝试向编译器展示一个既有可能返回x.f()，又有可能返回x.g()的情况。
这样子编译就无法通过了。

trait MyTrait {
    fn f(&self) -> Self;
    fn g(&self) -> u32;
}

impl MyTrait for u32 {
    fn f(&self) -> u32 { 42 }
    fn g(&self)->u32{1u32}
}

impl MyTrait for String {
    fn f(&self) -> String { self.clone() }
    fn g(&self)->u32{1u32}
}

fn my_function(x: impl MyTrait) -> impl MyTrait  {
    if true==false{
        return x.f();
    }
    return x.g();
}

我个认为原因是在编译器针对不同的类型进行模板特化时，除了u32这个类型以外，其他特化出来的函数都会存在返回两个不同类型的风险。

kahosan Mar 2, 2023 — with giscus

参考这段代码

trait MyTrait<T> {
    fn f(&self) -> T;
}

impl MyTrait<Self> for u32 {
    fn f(&self) -> Self {
        42
    }
}

impl MyTrait<Self> for String {
    fn f(&self) -> Self {
        self.clone()
    }
}

fn my_function<T: MyTrait<T>>(x: Box<impl MyTrait<T>>) -> impl MyTrait<T> {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

我觉得 Self 本身就是一种类型，指代实例本身

你的示例中，u32 与 Self 是两种不同的类型
在特征定义 Self 时，它应该是未知的，在不同的结构体或实现的时候，Self 就指代了不同的实例，但他们都是 Self 类型

kraymond37 Nov 21, 2023 — with giscus

我同意Nixicodo的说法, my_function(x: impl MyTrait) -> impl MyTrait只不过是fn my_function<T: MyTrait>(x: T) -> T的语法糖, 编译器会针对每种类型发散出该函数的专用变体, 查看可执行程序的符号也能够证实这一点, 所以不存在my_function返回两种不同的类型.

kraymond37 Nov 21, 2023 — with giscus

查看可执行程序的符号

nm target/debug/rusttest | grep my_function
0000000000008840 t _ZN8rusttest11my_function17h33bb2c02b4f2410cE
00000000000088a0 t _ZN8rusttest11my_function17he6c8f4e1b0e55b2eE

kraymond37 Nov 21, 2023 — with giscus

不同意kahosan的说法, Self确实是一个特殊的关键字, 但它只是表示当前类型. 参考下面这段代码, 都返回Self, 但是无法编译通过.

trait Hello {
    fn new() -> Self;
}    

struct A;
struct B;

impl A {
    fn new() -> Self {
        A
    }
}

impl B {
    fn new() -> Self {
        B
    }
}

fn returns_hello(switch: bool) -> impl Hello {
    if switch {
        A::new()
    } else {
        B::new()
    }
}

Nixicodo · 2023-03-02T03:00:40Z

Nixicodo
Mar 2, 2023 — with giscus

10.4特征对象第5题，我有一种邪道做法hhh，把函数都设置为不返回值

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self);
}

impl MyTrait for u32 {
    fn f(&self){ 42 ;}
}

impl MyTrait for String {
    fn f(&self)  { self.clone() ;}
}

fn my_function(x: Box<dyn MyTrait>)  {
    x.f();
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

1 reply

ARCJ137442 Feb 18, 2024 — with giscus

调用者：我**，我***🤣

XU0618 · 2023-05-03T13:36:20Z

XU0618
May 3, 2023 — with giscus

lala~

0 replies

Ghy0202 · 2023-07-17T08:06:53Z

Ghy0202
Jul 17, 2023 — with giscus

1、使用dny返回特征（当实现同一特征的是不同的结构体）

trait Bird {
    fn quack(&self) -> String;
}

struct Duck;
impl Duck {
    fn swim(&self) {
        println!("Look, the duck is swimming")
    }
}
struct Swan;
impl Swan {
    fn fly(&self) {
        println!("Look, the duck.. oh sorry, the swan is flying")
    }
}

impl Bird for Duck {
    fn quack(&self) -> String{
        "duck duck".to_string()
    }
}

impl Bird for Swan {
    fn quack(&self) -> String{
        "swan swan".to_string()
    }
}

fn main() {
    // 填空
    let duck = Duck;
    duck.swim();

    let bird = hatch_a_bird(2);
    // 变成鸟儿后，它忘记了如何游，因此以下代码会报错
    // bird.swim();
    // 但它依然可以叫唤
    assert_eq!(bird.quack(), "duck duck");

    let bird = hatch_a_bird(1);
    // 这只鸟儿忘了如何飞翔，因此以下代码会报错
    // bird.fly();
    // 但它也可以叫唤
    assert_eq!(bird.quack(), "swan swan");

    println!("Success!")
}   

// 注意写法Box封装
fn hatch_a_bird(op:i32)->Box<dyn Bird>{
    if op==1{
        Box::new(Swan)
    }else{
        Box::new(Duck)
    }
}

2、在数组中使用特征对象

trait Bird {
    fn quack(&self);
}

struct Duck;
impl Duck {
    fn fly(&self) {
        println!("Look, the duck is flying")
    }
}
struct Swan;
impl Swan {
    fn fly(&self) {
        println!("Look, the duck.. oh sorry, the swan is flying")
    }
}

impl Bird for Duck {
    fn quack(&self) {
        println!("{}", "duck duck");
    }
}

impl Bird for Swan {
    fn quack(&self) {
        println!("{}", "swan swan");
    }
}

fn main() {
    // 填空,这里必须要说明一下这个birds数组的类型是dyn不然其实在编辑器里面默认类型是vec<Box<Duck>>
       let birds:Vec<Box<dyn Bird>>=vec![
       Box::new(Duck),
       Box::new(Swan)
   ];

    for bird in birds {
        bird.quack();
    }
}

3、&dyn 和 Box的使用

一开始没有理解但是通过编译的版本：

// 填空
trait Draw {
    fn draw(&self) -> String;
}

impl Draw for u8 {
    fn draw(&self) -> String {
        format!("u8: {}", *self)
    }
}

impl Draw for f64 {
    fn draw(&self) -> String {
        format!("f64: {}", *self)
    }
}

fn main() {
    let x = 1.1f64;
    let y = 8u8;

    // draw x
    draw_with_box(Box::new(x));

    // draw y
    draw_with_ref(Box::new(y));

    println!("Success!")
}

fn draw_with_box(x: Box<dyn Draw>) {
    x.draw();
}

fn draw_with_ref(x: Box<dyn Draw>) {
    x.draw();
}

做完第四题回头发现自己的荒唐的版本：

// 填空
trait Draw {
    fn draw(&self) -> String;
}

impl Draw for u8 {
    fn draw(&self) -> String {
        format!("u8: {}", *self)
    }
}

impl Draw for f64 {
    fn draw(&self) -> String {
        format!("f64: {}", *self)
    }
}

fn main() {
    let x = 1.1f64;
    let y = 8u8;

    // draw x
    draw_with_box(Box::new(x));

    // draw y
    draw_with_ref(&y);

    println!("Success!")
}

fn draw_with_box(x: Box<dyn Draw>) {
    x.draw();
}

fn draw_with_ref(x: &dyn Draw) {
    x.draw();
}

4、静态分发和动态分发

trait Foo {
    fn method(&self) -> String;
}

impl Foo for u8 {
    fn method(&self) -> String { format!("u8: {}", *self) }
}

impl Foo for String {
    fn method(&self) -> String { format!("string: {}", *self) }
}

// 通过泛型实现以下函数
fn static_dispatch<T:Foo>(x:T){
    x.method();
}

// 通过特征对象实现以下函数
fn dynamic_dispatch(x:&dyn Foo){
    x.method();
}

fn main() {
    let x = 5u8;
    let y = "Hello".to_string();

    static_dispatch(x);
    dynamic_dispatch(&y);

    println!("Success!")
}

5、对象安全

我自己想到的比较简单的一种，移除Self对代码的影响……不过这样其实没体现对知识点的掌握

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self) ;
}

impl MyTrait for u32 {
    fn f(&self) { 42; }
}

impl MyTrait for String {
    fn f(&self) {  self.clone(); }
}

fn my_function(x: Box<dyn MyTrait>) {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

晕乎乎地看了答案

第一种，只要对象是实现了MyTrait同时返回MyTrait内置地方法即可

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> Self { 42 }
}

impl MyTrait for String {
    fn f(&self) -> Self { self.clone() }
}

fn my_function(x: impl MyTrait)->impl MyTrait  {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));

    println!("Success!")
}

第二种，把所有Self用Box<dyn MyTrait>替代一下

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self) -> Box<dyn MyTrait>;
}

impl MyTrait for u32 {
    fn f(&self) -> Box<dyn MyTrait>{
        Box::new(42)
    }
}

impl MyTrait for String {
    fn f(&self) -> Box<dyn MyTrait>{
        Box::new(self.clone())
    }
}

fn my_function(x: Box<dyn MyTrait>) -> Box<dyn MyTrait> {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

0 replies

chenhai998 · 2023-08-06T08:38:34Z

chenhai998
Aug 6, 2023 — with giscus

done

0 replies

yawyuen · 2023-09-27T15:25:44Z

yawyuen
Sep 27, 2023 — with giscus

第二题三种方式:

let birds:Vec<&dyn Bird> = vec![&Duck, &Swan]

let birds:Vec<Box<dyn Bird>>=vec![Box::new(Duck),Box::new(Swan)]

let birds:[Box<dyn Bird>;2] = [Box::new(Duck), Box::new(Swan)]

0 replies

doooooit · 2024-01-09T08:42:38Z

doooooit
Jan 9, 2024 — with giscus

第5题

使特征具备可以转换为特征对象的条件

trait MyTrait<T> {
    fn f(&self) -> T;
}

impl MyTrait<u32> for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait<String> for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function<T>(x: Box<dyn MyTrait<T>>) -> T {
    x.f()
}

fn main() {
    my_function(Box::new(13_u32));
    my_function(Box::new(String::from("abc")));

    println!("Success!")
}

不用特征对象

trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> Self { 42 }
}

impl MyTrait for String {
    fn f(&self) -> Self { self.clone() }
}

fn my_function(x: impl MyTrait) -> impl MyTrait {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));

    println!("Success!")
}

0 replies

dequeueing · 2024-02-01T09:01:30Z

dequeueing
Feb 1, 2024 — with giscus

第五题的官方题解：

    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> u32 { 42 }
}

impl MyTrait for String {
    fn f(&self) -> String { self.clone() }
}

fn my_function(x: impl MyTrait) -> impl MyTrait  {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));
}```
请教一下，`fn my_function(x: impl MyTrait) -> impl MyTrait` 不是只能返回同一种类型的吗？为什么这里既返回了数值又返回了String也可以运行呢？

1 reply

BiteFoo Feb 5, 2024 — with giscus

这个应该是错误的，不能返回impl Trait ，看下 gpt 的分析结果：

在 Rust 中，使用 impl Trait 语法作为函数的返回类型表示一个不透明类型，它使得函数可以返回实现了特定 trait 的类型，而不需要显式地指定具体的类型。但是，在您的情况下，将 my_function 函数的签名改为 fn my_function(x: Box) -> impl MyTrait 会导致编译错误，原因是返回的类型不是确定的。

具体来说，在 Rust 中，impl Trait 语法用于返回一个特定类型，而在您的情况下，函数 my_function 可能会返回不同的类型（取决于传入的 Box 中具体的类型）。这样的设计在 Rust 中是不允许的，因为函数的返回类型必须是确定的。

因此，您不能将 my_function 函数的签名改为 fn my_function(x: Box) -> impl MyTrait，因为这样的返回类型是不确定的，无法满足 Rust 的类型系统要求。您需要使用 Box 作为返回类型，或者通过泛型参数来实现函数的多态性。

ChinaRedArmy1930 · 2024-02-17T13:22:33Z

ChinaRedArmy1930
Feb 17, 2024 — with giscus

没太懂为什么第二题这样写就不行

    let birds: [Box<dyn Bird>; 2] = [Box::new(Duck), Box::new(Swan)]; //可以
   let birds: Vec<Box<dyn Bird>> = [Box::new(Duck), Box::new(Swan)]; //不行

1 reply

ChinaRedArmy1930 Feb 17, 2024 — with giscus

还是对rust语法不太熟悉，要这样写才行

  let birds: Vec<Box<dyn Bird>> = vec![Box::new(Duck), Box::new(Swan)];

BokutoMan · 2024-02-22T04:28:10Z

BokutoMan
Feb 22, 2024 — with giscus

down

0 replies

felipe300 · 2024-02-28T00:54:19Z

felipe300
Feb 28, 2024 — with giscus

done

0 replies

MTDickens · 2024-04-23T18:41:36Z

MTDickens
Apr 23, 2024 — with giscus

Done。最后一题，如果只考虑我们目前已经学过的方法，那么就是

将 dyn 变成泛型，反正输入输出的类型都一样，用泛型就 OK 了。
- 注意，这里同时要把 my_function 也改成泛型的方式实现
将 Self 变成 Box 就行了，不违反“返回类型不能是 Self”这条规定

题解

将 dyn 变成泛型。

虽然违反了第二条规定，但是我们只要避免使用 dyn 即可——将所有函数都改成泛型实现。

trait MyTrait {
    fn f(&self) -> Self;
}

impl MyTrait for u32 {
    fn f(&self) -> Self { 42 }
}

impl MyTrait for String {
    fn f(&self) -> Self { self.clone() }
}

fn my_function (x: impl MyTrait ) -> impl MyTrait {
    x.f()
}

fn main() {
    my_function(13_u32);
    my_function(String::from("abc"));

    println!("Success!")
}

返回 Box 而不是 Self

从而避免违反第一条规定。

trait MyTrait {
    fn f(&self) -> Box<dyn MyTrait>;
}

impl MyTrait for u32 {
    fn f(&self) -> Box<dyn MyTrait> { Box::new(42) }
}

impl MyTrait for String {
    fn f(&self) -> Box<dyn MyTrait> { Box::new(self.clone()) }
}

fn my_function (x: &dyn MyTrait ) -> Box<dyn MyTrait> {
    x.f()
}

fn main() {
    my_function(&13_u32);
    my_function(&String::from("abc"));

    println!("Success!")
}

1 reply

MTDickens Apr 23, 2024 — with giscus

为什么 SomeTrait 中的方法不能返回 Self 呢？因为 &dyn SomeTrait 可以认为是这样的对象：

不知道自己之前的类型是什么
只有对应 SomeTrait 中方法的函数指针（指向自己之前类的实现）。

因此，如果让它返回 Self，那么就相当于让它返回自己之前的类型。然而它已经不记得自己之前的类型了，所以这样做是不可行的。

Icemans007 · 2024-04-27T15:35:39Z

Icemans007
Apr 27, 2024 — with giscus

帮忙解答下这里是什么错误? &self.clone() 的类型和 self 的类型都是 &String，为什么clone的string取引用会报错？

// 使用至少两种方法让代码工作
// 不要添加/删除任何代码行
trait MyTrait {
    fn f(&self) -> &dyn MyTrait;
}

impl MyTrait for u32 {
    fn f(&self) -> &dyn MyTrait { &42 }
}

impl MyTrait for String {
    fn f(&self) -> &dyn MyTrait {
        // &self.clone() // 这里会失败 returns a value referencing data owned by the current function
        self  // 这里却可以
    }
}

fn my_function(x: &dyn MyTrait) -> &dyn MyTrait {
    x.f()
}

fn main() {
    my_function(&13_u32);
    my_function(&String::from("abc"));

    println!("Success!")
}

0 replies

DylanJinx · 2024-05-09T04:05:00Z

DylanJinx
May 9, 2024 — with giscus

done~~~

0 replies

unpain · 2024-05-21T08:51:07Z

unpain
May 21, 2024 — with giscus

done

0 replies

generics-traits/trait-object #220

giscus[bot] bot Apr 21, 2022

generics-traits/trait-object

Replies: 27 comments · 22 replies

lijing-2008 May 3, 2022 — with giscus

lijing-2008 May 3, 2022 — with giscus

s724123 Oct 20, 2022 — with giscus

doooooit Jan 9, 2024 — with giscus

lijing-2008 May 3, 2022 — with giscus

klenkiven May 22, 2022 — with giscus

jesHrz Jun 11, 2022 — with giscus

labuladong Aug 16, 2022 — with giscus

makexiao113 Jul 10, 2022 — with giscus

sunface Jul 11, 2022 Maintainer

DrEden33773 Sep 6, 2022 — with giscus

wangshankun Nov 15, 2022 — with giscus

lsmind Dec 12, 2022 — with giscus

DrEden33773 Sep 6, 2022 — with giscus

Tlntin Feb 6, 2023 — with giscus

DrEden33773 Feb 7, 2023

wangshankun Nov 15, 2022 — with giscus

EXSPIRAVIT1104OFFICIAL Nov 18, 2022 — with giscus

AliceThunder Nov 27, 2022 — with giscus

worldstearly Dec 7, 2022 — with giscus

Bruce012356 Jan 4, 2023 — with giscus

790228724 Jan 29, 2023 — with giscus

790228724 Jan 29, 2023 — with giscus

pluschen-stack Mar 1, 2023 — with giscus

Nixicodo Mar 2, 2023 — with giscus

kahosan Mar 2, 2023 — with giscus

kraymond37 Nov 21, 2023 — with giscus

kraymond37 Nov 21, 2023 — with giscus

kraymond37 Nov 21, 2023 — with giscus

Nixicodo Mar 2, 2023 — with giscus

ARCJ137442 Feb 18, 2024 — with giscus

XU0618 May 3, 2023 — with giscus

Ghy0202 Jul 17, 2023 — with giscus

chenhai998 Aug 6, 2023 — with giscus

yawyuen Sep 27, 2023 — with giscus

doooooit Jan 9, 2024 — with giscus

dequeueing Feb 1, 2024 — with giscus

BiteFoo Feb 5, 2024 — with giscus

ChinaRedArmy1930 Feb 17, 2024 — with giscus

ChinaRedArmy1930 Feb 17, 2024 — with giscus

BokutoMan Feb 22, 2024 — with giscus

felipe300 Feb 28, 2024 — with giscus

MTDickens Apr 23, 2024 — with giscus

题解

将 dyn 变成泛型。

返回 Box 而不是 Self

MTDickens Apr 23, 2024 — with giscus

Icemans007 Apr 27, 2024 — with giscus

DylanJinx May 9, 2024 — with giscus

unpain May 21, 2024 — with giscus

giscus[bot]
bot Apr 21, 2022

Replies: 27 comments 22 replies

lijing-2008
May 3, 2022 — with giscus

lijing-2008
May 3, 2022 — with giscus

lijing-2008
May 3, 2022 — with giscus

klenkiven
May 22, 2022 — with giscus

makexiao113
Jul 10, 2022 — with giscus

sunface Jul 11, 2022
Maintainer

DrEden33773
Sep 6, 2022 — with giscus

DrEden33773
Sep 6, 2022 — with giscus

wangshankun
Nov 15, 2022 — with giscus

EXSPIRAVIT1104OFFICIAL
Nov 18, 2022 — with giscus

AliceThunder
Nov 27, 2022 — with giscus

Bruce012356
Jan 4, 2023 — with giscus

790228724
Jan 29, 2023 — with giscus

pluschen-stack
Mar 1, 2023 — with giscus

Nixicodo
Mar 2, 2023 — with giscus

XU0618
May 3, 2023 — with giscus

Ghy0202
Jul 17, 2023 — with giscus

chenhai998
Aug 6, 2023 — with giscus

yawyuen
Sep 27, 2023 — with giscus

doooooit
Jan 9, 2024 — with giscus

dequeueing
Feb 1, 2024 — with giscus

ChinaRedArmy1930
Feb 17, 2024 — with giscus

BokutoMan
Feb 22, 2024 — with giscus

felipe300
Feb 28, 2024 — with giscus

MTDickens
Apr 23, 2024 — with giscus

Icemans007
Apr 27, 2024 — with giscus

DylanJinx
May 9, 2024 — with giscus

unpain
May 21, 2024 — with giscus