Rust 如何使用静态/动态调度实现iter方法？

我需要实现方法

iter

，它返回实现trait

迭代器的东西。但是，根据枚举变量的不同，返回值将是不同的实现

大概是这样的：

pub enum Class {
    SingleChar(char),
    Range(Range),
    And(Vec<Class>),
    Or(Vec<Class>),
}

impl Class {
    pub fn iter(&self) -> Iterator<Item = char> {
        match *self {
            Class::SingleChar(c) => vec![c],
            Class::Range(ref range) => range.iter(),
            Class::And(ref classes) => {
                let iter: Option<_> = classes.iter().fold(None, |iter, &class| {
                    match iter {
                        None => Some(class.iter()),
                        Some(iter) => Some(iter.merge(class.iter())),
                    }
                });
                Box::new(iter.unwrap())
            },
            Class::Or(ref classes) => {
                let iter: Option<_> = classes.iter().fold(None, |iter, &class| {
                    match iter {
                        None => Some(class.iter()),
                        Some(iter) => Some(iter.interleave(class.iter())),
                    }
                });
                Box::new(iter.unwrap())
            },
        }
    }
}

发布枚举类{
单字符（字符），
射程，
及(Vec),，
或(Vec),，
}
impl类{
pub fn iter（&self）->迭代器{
匹配自我{
类：：SingleChar（c）=>vec！[c]，
Class:：Range（ref Range）=>Range.iter（），
类：：和（参考类）=>{
让iter:Option=classes.iter（）.fold（无、iter和class）{
匹配iter{
None=>Some（class.iter（）），
Some（iter）=>Some（iter.merge（class.iter（）），
}
});
Box:：new（iter.unwrap（））
},
类：：或（参考类）=>{
让iter:Option=classes.iter（）.fold（无、iter和class）{
匹配iter{
None=>Some（class.iter（）），
Some（iter）=>Some（iter.interleave（class.iter（）），
}
});
Box:：new（iter.unwrap（））
},
}
}
}

range.iter（）
返回实现
迭代器的结构

merge
和
interleave
是分别返回
MergeAscend
和
interleave
的方法（它们都实现了
迭代器
）

如何使用静态调度实现这样的方案
如果无法进行静态调度，如何使用动态调度实现这种方案
使用静态分派是不可能的。对于未绑定的抽象返回类型有一个简单的定义，但是Rust还没有（我不确定它是否能够涵盖返回不同类型的用例）。因此，动态调度是一条必由之路

事实上，你很接近。只需创建返回类型
框
，并添加更多装箱：

pub fn iter(&self) -> Box<Iterator<Item=char>> {
    match *self {
        Class::SingleChar(c) => Box::new(Some(c).into_iter()),
        Class::Range(ref range) => Box::new(range.iter()),
        Class::And(ref classes) => {
            let iter: Option<_> = classes.iter().fold(None, |iter, &class| {
                match iter {
                    None => Some(Box::new(class.iter())),
                    Some(iter) => Some(Box::new(iter.merge(class.iter()))),
                }
            });
            iter.unwrap()
        },
        Class::Or(ref classes) => {
            let iter: Option<_> = classes.iter().fold(None, |iter, &class| {
                match iter {
                    None => Some(Box::new(class.iter())),
                    Some(iter) => Some(Box::new(iter.interleave(class.iter()))),
                }
            });
            iter.unwrap()
        },
    }
}

pub-fn-iter（&self）->Box{
匹配自我{
Class:：SingleChar（c）=>Box:：new（一些（c）.into_iter（）），
Class:：Range（ref Range）=>Box:：new（Range.iter（）），
类：：和（参考类）=>{
让iter:Option=classes.iter（）.fold（无、iter和class）{
匹配iter{
None=>Some（Box:：new（class.iter（）），
Some（iter）=>Some（Box:：new（iter.merge（class.iter（））），
}
});
iter.unwrap（）
},
类：：或（参考类）=>{
让iter:Option=classes.iter（）.fold（无、iter和class）{
匹配iter{
None=>Some（Box:：new（class.iter（）），
Some（iter）=>Some（Box:：new（iter.interleave（class.iter（））），
}
});
iter.unwrap（）
},
}
}

这应该行得通