无法找出一个函数来返回对存储在 RefCell> 中的给定类型的引用

其中大部分是样板文件，作为可编译的示例提供。向下滚动。

use std::rc::{Rc, Weak};
use std::cell::RefCell;
use std::any::{Any, AnyRefExt};

struct Shared {
    example: int,
}

struct Widget {
    parent: Option<Weak<Box<Widget>>>,
    specific: RefCell<Box<Any>>,
    shared: RefCell<Shared>,
}

impl Widget {
    fn new(specific: Box<Any>, 
           parent: Option<Rc<Box<Widget>>>) -> Rc<Box<Widget>> { 
        let parent_option = match parent {
            Some(parent) => Some(parent.downgrade()),
            None => None,
        };
        let shared = Shared{pos: 10};
        Rc::new(box Widget{
            parent: parent_option,
            specific: RefCell::new(specific),
            shared: RefCell::new(shared)})
    }
}

struct Woo {
    foo: int,
}

impl Woo {
    fn new() -> Box<Any> {
        box Woo{foo: 10} as Box<Any>
    }
}

fn main() {
    let widget = Widget::new(Woo::new(), None);

    {
        // This is a lot of work...
        let cell_borrow = widget.specific.borrow();
        let woo = cell_borrow.downcast_ref::<Woo>().unwrap();
        println!("{}", woo.foo);
    }

    // Can the above be made into a function?
    // let woo = widget.get_specific::<Woo>();
}

我正在学习 Rust 并试图找出一些可行的方法来构建小部件层次结构。上面基本上就满足了我的需要，但是有点麻烦。尤其令人烦恼的是，我必须使用两个语句来转换内部小部件（specific成员Widget）。我尝试了几种方法来编写一个可以完成这一切的函数，但是参考的数量和生命周期的魔力超出了我的范围。

能做到吗？我的示例代码底部注释掉的方法可以实现吗？

对于有关完成整个事情的更好方法的评论表示赞赏，但请将其放在评论部分（或创建一个新问题并将其链接）

我将仅介绍您的代码的工作简化版和更惯用的版本，然后解释我在那里所做的所有更改：

use std::rc::{Rc, Weak};
use std::any::{Any, AnyRefExt};

struct Shared {
    example: int,
}

struct Widget {
    parent: Option<Weak<Widget>>,
    specific: Box<Any>,
    shared: Shared,
}

impl Widget {
    fn new(specific: Box<Any>, parent: Option<Rc<Widget>>) -> Widget { 
        let parent_option = match parent {
            Some(parent) => Some(parent.downgrade()),
            None => None,
        };
        let shared = Shared { example: 10 };
        Widget{
            parent: parent_option,
            specific: specific,
            shared: shared
        }
    }

    fn get_specific<T: 'static>(&self) -> Option<&T> {
        self.specific.downcast_ref::<T>()
    }
}

struct Woo {
    foo: int,
}

impl Woo {
    fn new() -> Woo {
        Woo { foo: 10 }
    }
}

fn main() {
    let widget = Widget::new(box Woo::new() as Box<Any>, None);

    let specific = widget.get_specific::<Woo>().unwrap();
    println!("{}", specific.foo);
}

首先，有一些不必要的RefCell位于您的结构内部。RefCell很少需要 - 仅当您需要仅使用来改变对象的内部状态时&参考（而不是&mut）。这是实现抽象的有用工具，但在应用程序代码中几乎不需要它。因为从你的代码中并不清楚你really需要它，我认为它被错误使用并且可以删除。

Next, Rc<Box<Something>> when Something是一个结构（就像你的情况一样Something = Widget）是多余的。将拥有的框放入引用计数框只是不必要的双重间接和分配。清楚的Rc<Widget>是表达这件事的正确方式。当动态大小的类型落地时，特征对象也是如此。

最后，您应该尝试始终返回未装箱的值。返回Rc<Box<Widget>>（甚至Rc<Widget>) 对于代码的调用者来说是不必要的限制。你可以从Widget to Rc<Widget>很容易，但反之则不然。 Rust 自动优化按值回报；如果您的来电者需要Rc<Widget>他们可以自己装箱返回值：

let rc_w = box(RC) Widget::new(...);

同样的事情也适用于Box<Any>由返回Woo::new().

你可以看到，在没有RefCells your get_specific()方法可以非常容易地实现。但是，你真的不能这样做RefCell因为RefCell使用 RAII 进行动态借用检查，因此您无法从方法返回对其内部的引用。你必须回来core::cell::Refs，并且您的呼叫者将需要downcast_ref()他们自己。这只是使用的另一个原因RefCell是有节制的。