Rust泛型：列表中的每个元素都来自相同的特性？

huangapple
go评论92阅读模式
英文:

Rust generics: list where each element is from the same trait?

问题

我在Rust用户论坛上找到了这个问题：Generics: Can I say "tuple where each element is FromSql"。基本上，问题是想知道如何做类似这样的事情：

  1. trait Foo {}
  3. struct A {}
  4. impl Foo for A {}
  6. struct B {}
  7. impl Foo for B {}
  9. fn main() {
  10.     let x = (A{}, A{}, B{}, A{});
  11.     bar(x);
  12. }
  14. fn bar<T: Foo>(tuple: (T...)) {
  16. }

这段代码不起作用，只是一个可能的样子。

那么，我们该如何做呢？

英文:

I found this question on the Rust users forum : Generics: Can I say "tuple where each element is FromSql". Basically, the questions was to know how do something like that :

  1. trait Foo {}
  3. struct A {}
  4. impl Foo for A {}
  6. struct B {}
  7. impl Foo for B {}
  9. fn main() {
  10.     let x = (A{}, A{}, B{}, A{});
  11.     bar(x);
  12. }
  14. fn bar&lt;T: Foo&gt;(tuple: (T...)) {
  16. }

> This code does not work, it's an idea of how it could look like.

So, how can we do that?

答案1

得分: 0

  • 创建一个名为ToAny的特性，将为我们的所有结构体实现它。
  1. use std::any::Any;
  3. pub trait ToAny {
  4.     fn as_any(&self) -> &dyn Any;
  5. }
  • 让我们创建我们的特性
  1. trait Foo: ToAny {}

这需要实现ToAny特性，以强制每个实现Foo的结构体也实现ToAny。

  • 让我们创建我们的结构体：
  1. struct A {
  2.     id: i32,
  3. }
  5. impl ToAny for A {
  6.     fn as_any(&self) -> &dyn Any {
  7.         self
  8.     }
  9. }
  11. impl Foo for A {}
  13. struct B {
  14.     id: i32,
  15. }
  17. impl ToAny for B {
  18.     fn as_any(&self) -> &dyn Any {
  19.         self
  20.     }
  21. }
  23. impl Foo for B {}

ToAny的实现始终相同，我们可以轻松创建一个宏来实现它。

  • 然后，我们可以创建一个Vec来存储我们的值，而不是使用元组：
  1. let boxeds: Vec<Box<dyn A>> = vec![
  2.     Box::new(A {id: 1}),
  3.     Box::new(B {id: 2}),
  4.     Box::new(A {id: 3}),
  5.     Box::new(B {id: 4}),
  6. ];
  8. // 存储是`B`的值。
  9. let mut bees: Vec<&B> = vec![];
  11. for boxed in &boxeds {
  12.     // 如果`boxed`包含`B`值，则为`Some(x)`。
  13.     let found = match boxed.as_any().downcast_ref::<B>() {
  14.         Some(b) => b,
  15.         None => {}, // 这是`A`值。
  16.     };
  18.     bees.push(found);
  19. }
  21. assert_eq!(bees, vec![
  22.     &B {id: 2},
  23.     &B {id: 4}
  24. ]);

如果我们参考问题，以下代码：

  1. fn bar<T: Foo>(tuple: (T...)) {
  3. }

可以成为有效的代码：

  1. fn bar(values: Vec<Box<dyn Foo>) {
  3. }

我在这个帖子中已更改了名称，Foo 是 A，并且只有 B 结构体。

英文:
  • The first step is to create a ToAny trait that will be implemented for all our structures.
  1. use std::any::Any;
  3. pub trait ToAny {
  4.     fn as_any(&amp;self) -&gt; &amp;dyn Any;
  5. }
  • Let's create our trait
  1. trait Foo: ToAny {}

> It requires implementing the ToAny trait to force each structure implementing Foo to implement ToAny too.

  • Let's create our structures:
  1. struct A {
  2.     id: i32,
  3. }
  5. impl ToAny for A {
  6.     fn as_any(&amp;self) -&gt; &amp;dyn Any {
  7.         self
  8.     }
  9. }
  11. impl Foo for A {}
  13. struct B {
  14.     id: i32,
  15. }
  17. impl ToAny for B {
  18.     fn as_any(&amp;self) -&gt; &amp;dyn Any {
  19.         self
  20.     }
  21. }
  23. impl Foo for B {}

The implementation of ToAny is always the same, we could create a macro implementing it easily.

  • And then, we can create a Vec instead of a tuple to store our values:
  1. let boxeds: Vec&lt;Box&lt;dyn A&gt;&gt; = vec![
  2.     Box::new(A {id: 1}),
  3.     Box::new(B {id: 2}),
  4.     Box::new(A {id: 3}),
  5.     Box::new(B {id: 4}),
  6. ];
  8. // Stores the values being `B`.
  9. let mut bees: Vec&lt;&amp;B&gt; = vec![];
  11. for boxed in &amp;boxeds {
  12.     // `Some(x)` if `boxed` contains a `B` value.
  13.     let found = match boxed.as_any().downcast_ref::&lt;B&gt;() {
  14.         Some(b) =&gt; b,
  15.         None =&gt; {}, // it is a `A` value.
  16.     };
  18.     bees.push(found);
  19. }
  21. assert_eq!(bees, vec![
  22.     &amp;B {id: 2},
  23.     &amp;B {id: 4}
  24. ]);

If we refer to the question, the following code:

  1. fn bar&lt;T: Foo&gt;(tuple: (T...)) {
  3. }

can be this valid code:

  1. fn bar(values: Vec&lt;Box&lt;dyn Foo&gt;&gt;) {
  3. }

I've written a gist file being tests for that. Be careful, I've changed the names in this post, Foo is A and there is only the B structure.

答案2

得分: 0

  1. 使用宏来为元组实现 `Foo`：
  2. ```rust
  3. trait Foo {
  4.     fn do_it(&self);
  5. }
  7. struct A {}
  8. impl Foo for A {
  9.     fn do_it(&self) {
  10.         print!("A");
  11.     }
  12. }
  14. struct B {}
  15. impl Foo for B {
  16.     fn do_it(&self) {
  17.         print!("B");
  18.     }
  19. }
  21. fn main() {
  22.     let x = (A{}, A{}, B{}, A{});
  23.     bar(x);
  24. }
  26. fn bar<T: Foo>(tuple: T) {
  27.     tuple.do_it();
  28. }
  30. macro_rules! impl_Foo_for_tuple {
  31.     ( $first:ident $($rest:ident)* ) => {
  32.         impl<$first: Foo, $( $rest : Foo, )* > Foo for ( $first, $($rest,)* ) {
  33.             fn do_it(&self) {
  34.                 #[allow(non_snake_case)]
  35.                 let ( $first, $($rest,)* ) = self;
  36.                 $first.do_it();
  37.                 $( $rest.do_it(); )*
  38.             }
  39.         }
  40.         impl_Foo_for_tuple!( $($rest)* );
  41.     };
  42.     () => {};
  43. }
  44. impl_Foo_for_tuple!(A B C D E F G H I J K L M);
  2. <details>
  3. <summary>英文:</summary>
  5. Use a macro to implement `Foo` for tuples:
  6. ```rust
  7. trait Foo {
  8.     fn do_it(&amp;self);
  9. }
  11. struct A {}
  12. impl Foo for A {
  13.     fn do_it(&amp;self) {
  14.         print!(&quot;A&quot;);
  15.     }
  16. }
  18. struct B {}
  19. impl Foo for B {
  20.     fn do_it(&amp;self) {
  21.         print!(&quot;B&quot;);
  22.     }
  23. }
  25. fn main() {
  26.     let x = (A{}, A{}, B{}, A{});
  27.     bar(x);
  28. }
  30. fn bar&lt;T: Foo&gt;(tuple: T) {
  31.     tuple.do_it();
  32. }
  34. macro_rules! impl_Foo_for_tuple {
  35.     ( $first:ident $($rest:ident)* ) =&gt; {
  36.         impl&lt; $first: Foo, $( $rest : Foo, )* &gt; Foo for ( $first, $($rest,)* ) {
  37.             fn do_it(&amp;self) {
  38.                 #[allow(non_snake_case)]
  39.                 let ( $first, $($rest,)* ) = self;
  40.                 $first.do_it();
  41.                 $( $rest.do_it(); )*
  42.             }
  43.         }
  44.         impl_Foo_for_tuple!( $($rest)* );
  45.     };
  46.     () =&gt; {};
  47. }
  48. impl_Foo_for_tuple!(A B C D E F G H I J K L M);

huangapple
  • 本文由 发表于 2023年2月18日 21:36:55
  • 转载请务必保留本文链接：https://go.coder-hub.com/75493701.html
  • downcast
  • generics
  • rust
  • templates
  • tuples
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定