Trait object as associated type of a trait object.

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

Trait object as associated type of a trait object

问题

I can provide the translated code part as requested:

  1. 我编写了两个实现共同特征 `Solve` 的结构体。`Solve` 具有与特质绑定 `Display` 的关联类型 `Answer`。我希望函数 `create_solver` 返回 `Solve` 的特质对象。
  3. 我需要帮助编写关联类型 `Answer = ??`。
  5. ```rust
  6. use std::fmt::Display;
  8. fn main() {
  9.     let solver = create_solver(2);
  10.     
  11.     let answer = solver.solve();
  12.     
  13.     println!("{}", answer);
  14. }
  16. fn create_solver(kind: u32) -> Box<dyn Solve<Answer = ??>> {
  17.     match kind {
  18.         1 => Box::new(SolverOne),
  19.         2 => Box::new(SolverTwo),
  20.         _ => unreachable!()
  21.     }
  22. }
  24. trait Solve {
  25.     type Answer: Display;
  26.     
  27.     fn solve(&self) -> Self::Answer;
  28. }
  30. struct SolverOne;
  32. impl Solve for SolverOne {
  33.     type Answer = u32;
  35.     fn solve(&self) -> Self::Answer {
  36.         3
  37.     }
  38. }
  40. struct SolverTwo;
  42. impl Solve for SolverTwo {
  43.     type Answer = String;
  44.     
  45.     fn solve(&self) -> Self::Answer {
  46.         String::from("three")
  47.     }
  48. }

我尝试设置 Answer = Box<dyn Display>，但导致错误。

  1. fn create_solver(kind: u32) -> Box<dyn Solve<Answer = Box<dyn Display>>> {
  2.     match kind {
  3.         1 => Box::new(SolverOne),
  4.         2 => Box::new(SolverTwo),
  5.         _ => unreachable!()
  6.     }
  7. }
  9. trait Solve {
  10.     type Answer: Display;
  11.     
  12.     fn solve(&self) -> Self::Answer;
  13. }
  15. struct SolverOne;
  17. impl Solve for SolverOne {
  18.     type Answer = Box<u32>;
  20.     fn solve(&self) -> Self::Answer {
  21.         Box::new(3)
  22.     }
  23. }
  25. struct SolverTwo;
  27. impl Solve for SolverTwo {
  28.     type Answer = Box<String>;
  29.     
  30.     fn solve(&self) -> Self::Answer {
  31.         Box::new(String::from("three"))
  32.     }
  33. }

错误消息:

  1. error[E0271]: 类型不匹配，解析为 `<SolverOne as Solve>::Answer == Box<(dyn Display + 'static)>`
  2.   --> src/main.rs:13:14
  3.    |
  4. 13 |         1 => Box::new(SolverOne),
  5.    |              ^^^^^^^^^^^^^^^^^^^ 类型不匹配，解析为 `<SolverOne as Solve>::Answer == Box<(dyn Display + 'static)>`
  6.    |
  7. 注意: 预期为 `Box<(dyn std::fmt::Display + 'static)>`
  8.   --> src/main.rs:28:19
  9.    |
  10. 28 |     type Answer = Box<u32>;
  11.    |                   ^^^^^^^^
  12.    = 注意: 预期的结构是 `Box<(dyn std::fmt::Display + 'static)>`
  13.               找到的结构是 `Box<u32>`
  14.    = 注意: 需要将 `SolverOne` 转换为对象类型 `dyn Solve<Answer = Box<(dyn std::fmt::Display + 'static)>>`
  16. error[E0271]: 类型不匹配，解析为 `<SolverTwo as Solve>::Answer == Box<(dyn Display + 'static)>`
  17.   --> src/main.rs:12:5
  18.    |
  19. 12 | /     match kind {
  20. 13 | |         1 => Box::new(SolverOne),
  21. 14 | |         2 => Box::new(SolverTwo),
  22. 15 | |         _ => unreachable!()
  23. 16 | |     }
  24.    | |_____^ 类型不匹配，解析为 `<SolverTwo as Solve>::Answer == Box<(dyn Display + 'static)>`
  25.    |
  26. 注意: 预期为 `Box<(dyn std::fmt::Display + 'static)>`
  27.   --> src/main.rs:38:19
  28.    |
  29. 38 |     type Answer = Box<String>;
  30.    |                   ^^^^^^^^^^^
  31.    = 注意: 预期的结构是 `Box<(dyn std::fmt::Display + 'static)>`
  32.               找到的结构是 `Box<String>`
  33.    = 注意: 需要将 `SolverTwo` 转换为对象类型 `dyn Solve<Answer = Box<(dyn std::fmt::Display + 'static)>>`
  35. 有关此错误的更多信息，请尝试 `rustc --explain E0271`

您应该将 Answer = 设置为什么，以使其正常工作？

  2. 请注意，您要求翻译的代码片段可能包含代码错误或不完整的信息。因此，我无法为您提供完整的解决方案，但您需要将 `Answer` 设置为与实际返回类型匹配的类型，这可以是 `u32` 或 `String`，而不是 `Box<dyn Display>`。如果有其他问题，请提供更多详细信息，以便我可以提供更具体的帮助。
  3. <details>
  4. <summary>英文:</summary>
  5. I wrote two structs that implement a common trait `Solve`. `Solve` has an associated type `Answer` with trait bound `Display`. I want the function `create_solver` to return a trait object of `Solve`.
  6. I need help with writing the associate type `Answer = ??`.

use std::fmt::Display;

fn main() {
let solver = create_solver(2);

  1. let answer = solver.solve();
  2. println!(&quot;{}&quot;, answer);

}

fn create_solver(kind: u32) -> Box<dyn Solve<Answer = ??>> {
match kind {
1 => Box::new(SolverOne),
2 => Box::new(SolverTwo),
_ => unreachable!()
}
}

trait Solve {
type Answer: Display;

  1. fn solve(&amp;self) -&gt; Self::Answer;

}

struct SolverOne;

impl Solve for SolverOne {
type Answer = u32;

  1. fn solve(&amp;self) -&gt; Self::Answer {
  2. 3
  3. }

}

struct SolverTwo;

impl Solve for SolverTwo {
type Answer = String;

  1. fn solve(&amp;self) -&gt; Self::Answer {
  2. String::from(&quot;three&quot;)
  3. }

}

  2. I tried setting `Answer = Box&lt;dyn Display&gt;` but that results in error.

fn create_solver(kind: u32) -> Box<dyn Solve<Answer = Box<dyn Display>>> {
match kind {
1 => Box::new(SolverOne),
2 => Box::new(SolverTwo),
_ => unreachable!()
}
}

trait Solve {
type Answer: Display;

  1. fn solve(&amp;self) -&gt; Self::Answer;

}

struct SolverOne;

impl Solve for SolverOne {
type Answer = Box<u32>;

  1. fn solve(&amp;self) -&gt; Self::Answer {
  2. Box::new(3)
  3. }

}

struct SolverTwo;

impl Solve for SolverTwo {
type Answer = Box<String>;

  1. fn solve(&amp;self) -&gt; Self::Answer {
  2. Box::new(String::from(&quot;three&quot;))
  3. }

}

  2. Error message:

error[E0271]: type mismatch resolving &lt;SolverOne as Solve&gt;::Answer == Box&lt;(dyn Display + &#39;static)&gt;
--> src/main.rs:13:14
|
13 | 1 => Box::new(SolverOne),
| ^^^^^^^^^^^^^^^^^^^ type mismatch resolving &lt;SolverOne as Solve&gt;::Answer == Box&lt;(dyn Display + &#39;static)&gt;
|
note: expected this to be Box&lt;(dyn std::fmt::Display + &#39;static)&gt;
--> src/main.rs:28:19
|
28 | type Answer = Box<u32>;
| ^^^^^^^^
= note: expected struct Box&lt;(dyn std::fmt::Display + &#39;static)&gt;
found struct Box&lt;u32&gt;
= note: required for the cast from SolverOne to the object type dyn Solve&lt;Answer = Box&lt;(dyn std::fmt::Display + &#39;static)&gt;&gt;

error[E0271]: type mismatch resolving &lt;SolverTwo as Solve&gt;::Answer == Box&lt;(dyn Display + &#39;static)&gt;
--> src/main.rs:12:5
|
12 | / match kind {
13 | | 1 => Box::new(SolverOne),
14 | | 2 => Box::new(SolverTwo),
15 | | _ => unreachable!()
16 | | }
| |_____^ type mismatch resolving &lt;SolverTwo as Solve&gt;::Answer == Box&lt;(dyn Display + &#39;static)&gt;
|
note: expected this to be Box&lt;(dyn std::fmt::Display + &#39;static)&gt;
--> src/main.rs:38:19
|
38 | type Answer = Box<String>;
| ^^^^^^^^^^^
= note: expected struct Box&lt;(dyn std::fmt::Display + &#39;static)&gt;
found struct Box&lt;String&gt;
= note: required for the cast from SolverTwo to the object type dyn Solve&lt;Answer = Box&lt;(dyn std::fmt::Display + &#39;static)&gt;&gt;

For more information about this error, try rustc --explain E0271

  2. What should I set as `Answer = ` to make this work?
  3. </details>
  4. # 答案1
  5. **得分**: 2
  6. 以下是要翻译的内容：
  7. 关联类型必须对所有返回的类型相同，而您没有这样的关联类型。但您可以创建一个使用类型擦除返回 `Box<dyn Display>` 的包装类型：
  8. ```rust
  9. fn create_solver(kind: u32) -> Box<dyn Solve<Answer = Box<dyn Display>> {
  10. struct ErasedSolver<T>(T);
  11. impl<T: Solve> Solve for ErasedSolver<T>
  12. where
  13. T::Answer: 'static,
  14. {
  15. type Answer = Box<dyn Display>;
  16. fn solve(&self) -> Self::Answer {
  17. Box::new(self.0.solve())
  18. }
  19. }
  20. match kind {
  21. 1 => Box::new(ErasedSolver(SolverOne)),
  22. 2 => Box::new(ErasedSolver(SolverTwo)),
  23. _ => unreachable!(),
  24. }
  25. }
英文:

The associated type has to be the same for all types returned, and you have no such associated type. But you can create a wrapper type that using type erasure returns Box&lt;dyn Display&gt;:

  1. fn create_solver(kind: u32) -&gt; Box&lt;dyn Solve&lt;Answer = Box&lt;dyn Display&gt;&gt;&gt; {
  2.     struct ErasedSolver&lt;T&gt;(T);
  3.     impl&lt;T: Solve&gt; Solve for ErasedSolver&lt;T&gt;
  4.     where
  5.         T::Answer: &#39;static,
  6.     {
  7.         type Answer = Box&lt;dyn Display&gt;;
  9.         fn solve(&amp;self) -&gt; Self::Answer {
  10.             Box::new(self.0.solve())
  11.         }
  12.     }
  14.     match kind {
  15.         1 =&gt; Box::new(ErasedSolver(SolverOne)),
  16.         2 =&gt; Box::new(ErasedSolver(SolverTwo)),
  17.         _ =&gt; unreachable!(),
  18.     }
  19. }

答案2

得分: 0

以下是代码部分的翻译：

  1. 这几乎是与[使Clone对象安全][1]相同的问题，为此有[`dyn-clone`][2]。您可以通过创建另一个trait和一个全局impl来在这里执行相同的操作：
  3. trait SolveBoxed {
  4.     fn solve_boxed(&self) -> Box<dyn Display>;
  5. }
  7. impl<T, D> SolveBoxed for T
  8. where
  9.     T: Solve<Answer = D>,
  10.     D: Display + 'static,
  11. {
  12.     fn solve_boxed(&self) -> Box<dyn Display> {
  13.         Box::new(self.solve())
  14.     }
  15. }

完整代码：(playground)

  1. use std::fmt::Display;
  3. fn main() {
  4.     let solver = create_solver(2);
  6.     let answer = solver.solve_boxed();
  8.     println!("{}", answer);
  9. }
  11. fn create_solver(kind: u32) -> Box<dyn SolveBoxed> {
  12.     match kind {
  13.         1 => Box::new(SolverOne),
  14.         2 => Box::new(SolverTwo),
  15.         _ => unreachable!(),
  16.     }
  17. }
  19. trait SolveBoxed {
  20.     fn solve_boxed(&self) -> Box<dyn Display>;
  21. }
  23. impl<T, D> SolveBoxed for T
  24. where
  25.     T: Solve<Answer = D>,
  26.     D: Display + 'static,
  27. {
  28.     fn solve_boxed(&self) -> Box<dyn Display> {
  29.         Box::new(self.solve())
  30.     }
  31. }
  33. trait Solve {
  34.     type Answer: Display;
  36.     fn solve(&self) -> Self::Answer;
  37. }
  39. struct SolverOne;
  41. impl Solve for SolverOne {
  42.     type Answer = u32;
  44.     fn solve(&self) -> Self::Answer {
  45.         3
  46.     }
  47. }
  49. struct SolverTwo;
  51. impl Solve for SolverTwo {
  52.     type Answer = String;
  54.     fn solve(&self) -> Self::Answer {
  55.         String::from("three")
  56.     }
  57. }
  2. <details>
  3. <summary>英文:</summary>
  4. This is almost the same problem as [making Clone object-safe][1], for which there&#39;s [`dyn-clone`][2]. You can do the same thing here by making another trait and a blanket impl:
  5. ```rs
  6. trait SolveBoxed {
  7. fn solve_boxed(&amp;self) -&gt; Box&lt;dyn Display&gt;;
  8. }
  9. impl&lt;T, D&gt; SolveBoxed for T
  10. where
  11. T: Solve&lt;Answer = D&gt;,
  12. D: Display + &#39;static,
  13. {
  14. fn solve_boxed(&amp;self) -&gt; Box&lt;dyn Display&gt; {
  15. Box::new(self.solve())
  16. }
  17. }

Full code: (playground)

  1. use std::fmt::Display;
  3. fn main() {
  4.     let solver = create_solver(2);
  6.     let answer = solver.solve_boxed();
  8.     println!(&quot;{}&quot;, answer);
  9. }
  11. fn create_solver(kind: u32) -&gt; Box&lt;dyn SolveBoxed&gt; {
  12.     match kind {
  13.         1 =&gt; Box::new(SolverOne),
  14.         2 =&gt; Box::new(SolverTwo),
  15.         _ =&gt; unreachable!(),
  16.     }
  17. }
  19. trait SolveBoxed {
  20.     fn solve_boxed(&amp;self) -&gt; Box&lt;dyn Display&gt;;
  21. }
  23. impl&lt;T, D&gt; SolveBoxed for T
  24. where
  25.     T: Solve&lt;Answer = D&gt;,
  26.     D: Display + &#39;static,
  27. {
  28.     fn solve_boxed(&amp;self) -&gt; Box&lt;dyn Display&gt; {
  29.         Box::new(self.solve())
  30.     }
  31. }
  33. trait Solve {
  34.     type Answer: Display;
  36.     fn solve(&amp;self) -&gt; Self::Answer;
  37. }
  39. struct SolverOne;
  41. impl Solve for SolverOne {
  42.     type Answer = u32;
  44.     fn solve(&amp;self) -&gt; Self::Answer {
  45.         3
  46.     }
  47. }
  49. struct SolverTwo;
  51. impl Solve for SolverTwo {
  52.     type Answer = String;
  54.     fn solve(&amp;self) -&gt; Self::Answer {
  55.         String::from(&quot;three&quot;)
  56.     }
  57. }

huangapple
  • 本文由 发表于 2023年3月21日 02:07:51
  • 转载请务必保留本文链接：https://go.coder-hub.com/75793849.html
  • associated-types
  • dynamic-dispatch
  • rust
  • trait-objects
匿名

发表评论

匿名网友

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

确定