是否有任何方法可以转换为泛型T，其中T是任意的特征类型？

Question

我的问题标题有点模糊，但本质上我想实现以下几点：

• struct Foo实现行为A和行为B和行为C
• 结构栏实现行为A
• Foo和Bar都实现了一些Content特性
• 从一个

从广义上讲，这是可能的，通过强制Content明确地了解行为A等，如：

fn as_a(&self) -> Option<&BehaviourA>

但是，这要求内容类型明确了解所有行为类型，如果内容作为api导出到板条箱中，这是不可能的。

理想情况下，内容将具有如下api：

fn behaviour<T>(&self) -> Option<T> where T: Any;

可在运行时调用，如下所示：

match content_item.behaviour::<&BehaviourA>() {
  Some(x) => { ... },
  None => {}
}

但是，我找不到任何方法来实现此功能。

我最好的尝试是这样的：

fn behaviour<T>(&self) -> Option<T> where T: Any {
  let own_type = TypeId::of::<T>();
  if own_type == TypeId::of::<Behaviour>() { return Some(self as T); }
  return None;
}

但这会导致：

src/foo.rs:21:62: 21:71 error: non-scalar cast: `&interface::test::Foo` as `T`
src/foo.rs:21       if own_type == TypeId::of::<Behaviour>() { return Some(self as T); }

我知道没有办法在运行时内省对象的特性列表，但这里我显式地将其转换为实现中的已知类型；很简单，界T并不总是满足的。

有什么方法可以做到这一点，即使是不安全的？

显示错误的playpen示例如下：http://is.gd/fZNFA8

（注意，我已经看到你能将泛型限制为T，其中T是Self实现的特征吗？），但我的问题不同；简而言之，有没有任何方法，甚至不安全地在运行时生成特征引用？）




Answer 1

这里的根本问题是，特质不是类型。当你说

可悲的是，从1.6开始，仍然没有办法做到这一点。

我所知道的使类似的东西能够工作的唯一方法是显式的a-la COM：您需要一个基本接口，它允许您请求“转换到X”的引用，然后在每个具体类型上为所有支持的X实现它。

如果你愿意涉足不安全、混乱的代码，你可以通过一些宏（游戏笔）得到你想要的东西：

// Requires nightly compiler, since it depends on implementation details.
#![feature(raw)]

use std::any::TypeId;
use std::mem::transmute;
use std::raw::TraitObject;

macro_rules! qi {
    ($e:expr, $t:ty) => {
        unsafe {
            let iid = TypeId::of::<$t>();
            let ptr = &$e;
            match ptr.query_interface(&iid) {
                Some(to) => {
                    let tmp: &$t = transmute(to);
                    Some(tmp)
                },
                None => None,
            }
        }
    };
}

macro_rules! impl_unknown_for {
    ($base:ty: $($ints:ty),*) => {
        unsafe impl Unknown for $base {
            fn query_interface(&self, iid: &TypeId) -> Option<TraitObject> {
                unsafe {
                    $(
                        if *iid == TypeId::of::<$ints>() {
                            let to = transmute::<&$ints, _>(self);
                            return Some(to);
                        }
                    )*
                    None
                }
            }
        }
    };
}

unsafe trait Unknown {
    fn query_interface(&self, iid: &TypeId) -> Option<TraitObject>;
}

trait BehaviourA { fn a(&self); }
trait BehaviourB { fn b(&self); }
trait BehaviourC { fn c(&self); }

struct Thingy;

impl_unknown_for!(Thingy: BehaviourA, BehaviourC);

impl BehaviourA for Thingy {
    fn a(&self) { println!("Thingy::a"); }
}

impl BehaviourC for Thingy {
    fn c(&self) { println!("Thingy::c"); }
}

fn main() {
    let obj: Box<Unknown> = Box::new(Thingy);
    if let Some(ba) = qi!(obj, BehaviourA) { ba.a(); }
    if let Some(bb) = qi!(obj, BehaviourB) { bb.b(); }
    if let Some(bc) = qi!(obj, BehaviourC) { bc.c(); }
}