如何从trait对象获得任何：downcast_ref的所有权？

Question

我遇到了与Rust的所有权规则和特性对象downcast的冲突。这是一个示例：

use std::any::Any;
trait Node{
    fn gen(&self) -> Box<Node>;
}

struct TextNode;
impl Node for TextNode{
    fn gen(&self) -> Box<Node>{
        Box::new(TextNode)
    }
}

fn main(){
    let mut v: Vec<TextNode> = Vec::new();
    let node = TextNode.gen();
    let foo = &node as &Any;
    match foo.downcast_ref::<TextNode>(){
        Some(n) => {
            v.push(*n);
        },
        None => ()
    };

}

TextNode::gen方法必须返回Box

任何::downcast_ref的返回值是

==编辑=====

由于我英语不好，我的问题很模糊。

我正在Go标准库中实现（复制可能更精确）模板解析器。

我真正需要的是一个向量，Vec

每个节点类型都需要实现复制方法，返回Box

如果复制方法返回Box




Answer 1

解决问题的（更）意识形态方式：

use std::any::Any;

pub trait Nodeable {
    fn as_any(&self) -> &dyn Any;
}

#[derive(Clone, Debug)]
struct TextNode {}

impl Nodeable for TextNode {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

fn main() {
    let mut v: Vec<Box<dyn Nodeable>> = Vec::new();
    let node = TextNode {};  // or impl TextNode::new

    v.push(Box::new(node));

    // the downcast back to TextNode could be solved like this:
    if let Some(b) = v.pop() {  // only if we have a node…
        let n = (*b).as_any().downcast_ref::<TextNode>().unwrap();  // this is secure *)
        println!("{:?}", n);
    };
}

*)这是安全的：只有nodables被允许降级到实现了nodable的类型。

Answer 2

如果你控制了trait Node，你可以让它返回一个Box

它看起来是这样的：

use std::any::Any;
trait Node {
    fn gen(&self) -> Box<Any>; // downcast works on Box<Any>
}

struct TextNode;

impl Node for TextNode {
    fn gen(&self) -> Box<Any> {
        Box::new(TextNode)
    }
}

fn main() {
    let mut v: Vec<TextNode> = Vec::new();
    let node = TextNode.gen();

    if let Ok(n) = node.downcast::<TextNode>() {
        v.push(*n);
    }
}

一般来说，您不应该直接使用Any。我知道，当它来自一种具有子类型多态性的语言时，它看起来很熟悉，并且想要用一些根类型重新创建类型的层次结构（比如在本例中：您试图重新创建TextNode是一个节点关系，并创建一个节点的Vec）。我也这么做了，其他很多人也这么做了：我打赌Any上的so问题数量超过了Any在板条箱上实际使用的次数。木卫一。

虽然任何代码都有它的用途，但在Rust中它有替代品。如果你没有看过它们，我想确保你考虑过这样做：

给定不同的节点类型，您可以用枚举表示“节点是这些类型中的任何一种”关系：

struct TextNode;
struct XmlNode;
struct HtmlNode;

enum Node {
    Text(TextNode),
    Xml(XmlNode),
    Html(HtmlNode),
}

有了它，您可以将它们全部放在一个Vec中，并根据变量执行不同的操作，而无需向下转换：

let v: Vec<Node> = vec![
    Node::Text(TextNode),
    Node::Xml(XmlNode),
    Node::Html(HtmlNode)];

for n in &v {
    match n {
        &Node::Text(_) => println!("TextNode"),
        &Node::Xml(_) => println!("XmlNode"),
        &Node::Html(_) => println!("HtmlNode"),
    }
}

游戏场

添加变量意味着可能在许多地方更改代码：enum本身和所有使用enum的函数（为新变量添加逻辑）。但是，同样地，对于Any，它基本上是相同的，所有这些函数可能都需要向新的变体添加向下转换。

您可以尝试将要执行的操作放在trait中各种类型的节点上，这样就不需要向下转换，只需调用trait对象上的方法。这基本上就是您正在做的事情，除了将方法放在节点特征上而不是向下转换。

游戏场