在 Rust 中，fn 参数的协方差用什么?

今天我了解到 rust 不支持 fn 参数的协方差，只有它的返回类型是协变的。(见锈文档(

为什么我在 rust 中了解到这一事实？因为我试图实现一个非常简单的游戏，其中我将逻辑、事件处理和绘图分离到三个不同的函数中，但都在相同的玩家向量上运行。

如果这是不可能的，那么与 c# 版本相比，rust 中的等效物是什么？

在 C# 中，这是非常简单的小提琴您可以定义类 X 必须实现的接口 Y，并定义相应的委托，该委托需要该接口 Y 的 IEnumerable 作为参数。现在，您可以在只需要接口 Y 的不同方法之间共享 X 列表。

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();
}
}
);
}
}

虽然我很天真，但我试图做一些与生锈相当的事情！

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 中，很少有事情是隐式完成的，其中包括你发现的强制转换。

在这种情况下，将Vec<&T>转换为Vec<&dyn Trait>是不可能的(鉴于T != dyn Trait(，因为特征对象的存储方式;它们是两个指针宽度宽，而普通引用是一个指针宽度宽。这意味着Vec的长度，以字节为单位需要加倍。

我接受这在生锈中是不可能的。我想知道锈中用的是什么

如果您只使用一种对象，则可以只限制类型：

type DrawHandler = fn(drawables: &Vec<Player>) -> Result<(), String>;
type LogicHandler = fn(actions: &Vec<Player>) -> Result<(), String>;

但是，您的游戏中很可能不仅有玩家，而且您希望包含其他方面。

这可以通过几种方式完成：

使用enums 表示每种类型的对象。然后你的函数输入可以取enum类型的值：

enum GamePiece {
Player(Player),
Enemy(Enemy),
Item(Item),
//etc.
}

使用可以根据对象具有的属性管理任意对象的 ECS。一些 rust 存在的弹性云服务器有：
- legion
- specs
- ecs
- shipyard
- 还有更多
通常，它们的用法如下所示：

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看起来像在超类型中使用子类型，但实际上它是一种类型转换(两者在内存中看起来完全不同@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的后果 - 这不是解决问题的最佳方式。

相关内容

最新更新

热门标签：