[英]What to use for covariance over fn parameter in Rust?
今天我了解到 rust 不支持 fn 参数的协变,只有它的返回类型是协变的。 (见 rust 文档)
为什么我会在 rust 中了解到这个事实? 因为我试图实现一个非常简单的游戏,其中我将逻辑、事件处理和绘图分离为三个不同的函数,但它们都在同一个玩家向量上运行。
如果这是不可能的,那么与 c# 版本相比,rust 中的等效项是什么?
在 C# 这很简单Fiddle您可以定义一个接口 Y,class X 必须实现并定义一个相应的委托,该委托需要该接口 Y 的 IEnumerable 作为参数。现在您可以在需要的不同方法之间共享 X 列表只有一个接口 Y。
using System;
using System.Collections.Generic;
public interface Actionable{
void Do();
}
public interface Drawable{
void Draw();
}
public class Player: Drawable, Actionable{
public void Do(){
Console.WriteLine("Action");
}
public void Draw(){
Console.WriteLine("Draw");
}
}
public class Program
{
public delegate void DrawHandler(IEnumerable<Drawable> obj);
public delegate void LogicHandler(IEnumerable<Actionable> obj);
public static void gameloop(DrawHandler draw,LogicHandler action){
List<Player> list = new List<Player>(){
new Player()
};
for(int rounds = 0; rounds < 500; rounds++){
draw(list);
action(list);
}
}
public static void Main()
{
gameloop(
list =>{
foreach(var item in list){
item.Draw();
}
},
list =>{
foreach(var item in list){
item.Do();
}
}
);
}
}
尽管我很天真,但我试图做一些与 rust 相同的事情!
trait Drawable {
fn draw(&self) {
println!("draw object");
}
}
trait Actionable {
fn do_action(&self, action: &String) {
println!("Do {}", action);
}
}
#[derive(Debug)]
struct Position {
x: u32,
y: u32,
}
impl Position {
fn new(x: u32, y: u32) -> Position {
Position { x, y }
}
}
#[derive(Debug)]
struct Player {
pos: Position,
name: String,
}
impl Player {
fn new(name: String) -> Player {
Player {
name,
pos: Position::new(0, 0),
}
}
}
impl Drawable for Player {
fn draw(&self) {
println!("{:?}", self);
}
}
impl Actionable for Player {
fn do_action(&self, action: &String) {
println!("Do {} {}!", action, self.name);
}
}
type DrawHandler = fn(drawables: &Vec<&dyn Drawable>) -> Result<(), String>;
type LogicHandler = fn(actions: &Vec<&dyn Actionable>) -> Result<(), String>;
type EventHandler = fn(events: &mut sdl2::EventPump) -> Result<bool, String>;
fn game_loop(
window: &mut windowContext,
draw_handler: DrawHandler,
event_handler: EventHandler,
logic_handler: LogicHandler,
) -> Result<(), String> {
let mut objects: Vec<&Player> = Vec::new();
objects.push(&Player::new("b".to_string()));
while event_handler(&mut window.events)? {
logic_handler(&objects)?; // Does Not work
window.canvas.clear();
draw_handler(&objects)?; // Does Not Work
window.canvas.present();
::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 60));
}
Ok(())
}
如果这是不可能的,那么与 c# 版本相比,rust 中的等效项是什么?
我接受这在 rust 中是不可能的。 我想知道在 rust 中使用的是什么
在 Rust 中,很少有事情是隐式完成的,包括您发现的强制转换。
在这种情况下,将Vec<&T>
转换为Vec<&dyn Trait>
是不可能的(鉴于T != dyn Trait
),因为 trait 对象是如何存储的; 它们是两个指针宽度,而普通引用是一个指针宽度。 这意味着Vec
的长度(以字节为单位)需要加倍。
我接受这在 rust 中是不可能的。 我想知道在 rust 中使用的是什么
如果你只使用一种 object,你可以限制类型:
type DrawHandler = fn(drawables: &Vec<Player>) -> Result<(), String>;
type LogicHandler = fn(actions: &Vec<Player>) -> Result<(), String>;
但是,您的游戏中很可能不仅有玩家,而是您希望包括其他方面。
这可以通过以下几种方式完成:
enum
来表示 object 的每种类型。 然后您的 function 输入可以采用enum
类型的值:enum GamePiece {
Player(Player),
Enemy(Enemy),
Item(Item),
//etc.
}
struct DrawingComponent {
buffers: Buffer
}
struct DirectionAI {
direction: Vector
}
struct Position {
position: Point
}
let mut world = World::new();
world.insert((DrawingComponent::new(), DirectionAI::new(), Position::new()));
for (pos, direction) in world.iter_over(<(&mut Position, &DirectionAI)>::query()) {
pos.position += direction.direction;
}
for (pos, drawable) in world.iter_over(<&Position, &mut DrawingComponent>::query()) {
drawable.buffers.set_position(*pos);
draw(drawable);
}
在这个系统中,您通常在组件上工作,而不是在类型上工作。 这样,ECS 可以非常快速、高效地存储和访问项目。
Rust 中的协方差确实存在。 这不是 OOP 协方差,而是生命周期内的协方差。 Rust Nomicon 涵盖了它,因为它对于日常用户来说有点小众。
请注意,该部分中的表格涵盖了'a
、 T
以及在某些情况下U
的方差。 在T
和U
的情况下,那里的方差存在于它们可能具有的任何生命周期参数中,而不是类型本身。 IE,它描述了'b
在Struct<'b>
中如何变体(或不变),而不是如何将Struct<'b>
强制转换为dyn Trait + 'b
。
将&Player
视为&dyn Drawable
看起来像是在超类型中使用子类型,但实际上它是一种类型转换(两者在 memory 中看起来完全不同 @Optimistic Peach 对此进行了更详细的解释)。
考虑到这一点, Vec<Player>
不能被转换成Vec<&dyn Drawable>
,它必须被转换。 具有显式转换的代码如下所示:
fn game_loop(
draw_handler: DrawHandler,
logic_handler: LogicHandler,
) -> Result<(), String> {
let mut objects: Vec<Player> = Vec::new();
objects.push(Player::new("b".to_string()));
for i in 0..1 {
let actionable = objects.iter().map(|v| v as &dyn Actionable).collect();
logic_handler(&actionable)?; // Does work!
let drawables = objects.iter().map(|v| v as &dyn Drawable).collect();
draw_handler(&drawables)?; // Does work!
}
Ok(())
}
这应该只演示将&Player
转换为&dyn Drawable
的后果 - 这不是解决问题的最佳方法。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.