closures - 类型错误调用存储在结构中的闭包

Question

我最近开始尝试用 Rust 编写一些玩具程序，我想我想尝试一下解析器组合器。我天真的尝试是这样的:

enum ParseResult<T> {
    Ok(T),
    Error (String),
}

struct Parser<'a, I,O>{
    Parse: |I|:'a ->ParseResult<O>,
}
impl<'a, I,O,J> Parser<'a, I, O>{
    fn Compose<I,O,K>(self, RHS : Parser<O,K> )->Parser<I,K>{
        Parser
        {
            Parse :  |x:I|
               {
                   let intermediate = self.Parse;
                   match intermediate(x){ //mismatched types: expected `I` but found `I` (expected type parameter but found type parameter)

                       Ok(result) =>
                       {
                           let final = RHS.Parse;
                           final(result) mismatched types: expected `O` but found `0` (expected type parameter but found type parameter)

                       }          
                      Error(result) => Error(result)
                   }
               }
        }
    }
}

我很确定错误表明我的方法存在更根本的错误，但我不太确定是什么。

Answer 1

确实，您的程序中存在一些错误。

目前闭包是堆栈式“盒装”的，因此您不能从函数中返回它们，而这正是您的示例中发生的情况 - 您将闭包存储在 Parser 结构中。

另一个错误是通用参数的不正确使用。即使没有闭包，您的方法也无法正常工作:Compose 方法中的 I 和 O 参数与 impl 中的参数不同> 子句，即使它们共享相同的名称。

顺便说一句，您不需要将闭包移动到 intermediate 变量中。要调用存储在字段中的闭包，您需要这样做:

let intermediate = (self.Parse)(x);

就是说，几天前拆箱的关闭终于落地了。有了它们，您可以做您想做的事，尽管目前有点麻烦。

#![feature(unboxed_closures)]

struct Parser<I, O> {
    parse: Box<FnMut<(I,), Result<O, String>>>
}

impl<I, O> Parser<I, O> {
    fn compose<K>(mut self, mut rhs: Parser<O, K>) -> Parser<I, K> {
        Parser {
            parse: box |&mut: x: I| {
                match self.parse.call_mut((x,)) {
                    Ok(r) => rhs.parse.call_mut((r,)),
                    Err(e) => Err(e)
                }
            }
        }
    }
}

这应该 工作但现在它 doesn't ，这对我来说就像一个错误:

<anon>:11:23: 11:33 error: cannot borrow data mutably in an aliasable location
<anon>:11                 match self.parse.call_mut((x,)) {
                                ^~~~~~~~~~
<anon>:12:35: 12:44 error: cannot borrow data mutably in an aliasable location
<anon>:12                     Ok(result) => rhs.parse.call_mut((result,)),
                                            ^~~~~~~~~

当我用手动展开的未装箱闭包重写这个例子时它起作用了，所以这里肯定有一些编译器问题。未装箱的闭包非常新，所以这样的事情并不意外。我有 submitted an issue对此。