Rust 为什么我会得到这个错误；不能多次借用x作为可变项"；？

我正在Rust中实现一个解析器。我必须更新前瞻的索引，但是在

self.current（）

之后调用

self.get（）

时，我会得到一个错误：

cannot borrow *self as mutable more than once at a time

这让人困惑，因为我是新手

#[derive(Debug)]
pub enum Token {
    Random(String),
    Undefined(String),
}

struct Point {
    token: Vec<Token>,
    look: usize,
}

impl Point {
    pub fn init(&mut self){
        while let Some(token) = self.current(){
            println!("{:?}", token); 
            let _ = self.get();
        }
    }

    pub fn current(&mut self) -> Option<&Token> {
        self.token.get(self.look)
    }

    pub fn get(&mut self) -> Option<&Token> {
        let v = self.token.get(self.look);
        self.look += 1;
        v
    }

}

fn main(){
    let token_list = vec![Token::Undefined("test".to_string()),
                     Token::Random("test".to_string())];

    let mut o = Point{ token: token_list, look: 0 };
    o.init();
}

#[派生（调试）]
发布枚举令牌{
随机（字符串），
未定义（字符串），
}
结构点{
令牌：Vec，
看：用，
}
内点{
发布fn初始（&M自我）{
而让一些（令牌）=self.current（）{
println！（“{：？}”，标记）；
让u=self.get（）；
}
}
发布fn当前（&mut self）->选项{
self.token.get（self.look）
}
pub fn get（&mut self）->选项{
设v=self.token.get（self.look）；
self.look+=1；
v
}
}
fn main（）{
让token_list=vec！[token:：Undefined（“test.”to_string（）），
令牌：：随机（“test.to_string（））]；
设muto=Point{token:token_list，look:0}；
o、 init（）；
}

函数

Point:：get

对调用它的

点进行变异。函数
Point:：current
返回对调用它的
点的一部分的引用。所以，当你写作的时候

while let Some(token) = self.current() {
    println!("{:?}", token); 
    let _ = self.get();
}

token
是对
self
中存储的内容的引用。由于变异
self
可能会更改或删除
token
指向的任何对象，因此当变量
token
在作用域内时，编译器会阻止您调用
self.get（）
。
函数
Point:：get
变异调用它的
点。函数
Point:：current
返回对调用它的
点的一部分的引用。所以，当你写作的时候

while let Some(token) = self.current() {
    println!("{:?}", token); 
    let _ = self.get();
}

token
是对
self
中存储的内容的引用。由于变异
self
可能会更改或删除
token
指向的任何内容，因此当变量
token
在作用域内时，编译器会阻止您调用
self.get（）
。
@Adrian已经给出了编译器发出错误消息的正确原因。如果将变异表达式绑定到一个作用域内，然后在作用域完成后调用
self.get
，则可以编译程序。

代码可以修改为

loop{
    {
        let t = if let Some(token) = self.current(){
                    token
                }else{
                    break
                };
        println!("{:?}", t); 
    }
    let b = self.get();
    println!("{:?}", b);
}

@Adrian已经给出了编译器发出错误消息的正确原因。如果将变异表达式绑定到一个作用域内，然后在作用域完成后调用
self.get
，则可以编译程序。

代码可以修改为

loop{
    {
        let t = if let Some(token) = self.current(){
                    token
                }else{
                    break
                };
        println!("{:?}", t); 
    }
    let b = self.get();
    println!("{:?}", b);
}

在rust中做这样的事情的正确方法是什么？@上帝重组你的代码，这样你就不会保留对正在变异的事物的引用在rust中做这样的事情的正确方法是什么？@上帝重组你的代码，这样你就不会保留对正在变异的事物的引用