Rust 可变结构域

我知道可变字段在0.6中被删除。我在这段代码中遇到以下错误

C:\Users\mflamer\Dropbox\Rust\Tests\gmap.rs:23:8:23:18错误： 分配给不可变字段 C:\Users\mflamer\Dropbox\Rust\Tests\gmap.rs:23 dart.alpha= vec：：from_elem（self.n+1，dart）

我做错了什么？谢谢

pub struct GMap<T> {
        priv     n: uint,
        priv darts: ~[Dart<T>]
    }

struct Dart<T> {
    alpha: ~[@Dart<T>],
    embed: ~[@T],
   tagged: bool
}

impl<T> GMap<T> {
    pub fn new(dim: uint) -> GMap<T> {      
        let mut map: GMap<T> = GMap{n: dim, darts: ~[]};
        return map
    }
    pub fn new_dart(&self, ) -> @Dart<T> {
        let mut dart = @Dart{alpha: ~[], embed: ~[], tagged: false};        
        dart.alpha = vec::from_elem(self.n + 1, dart); 
        //dart.embed = vec::from_elem(self.n + 1, );
        return dart;
    }
    pub fn dim(&self) -> uint {
        self.n 
    }
}


//pub fn traverse(&self,[bool,..])


enum Cell {
    Null,
    Vertex,
    Edge,
    Face,
    Solid
}   

fn main() { 
    let topo: GMap<Cell> = GMap::new(3);    
}

pub结构GMap{
priv n:uint，
私人飞镖：~[飞镖]
}
结构省{
阿尔法：~[@Dart]，
嵌入：~[@T]，
标签：布尔
}
impl GMap{
pub fn new（dim:uint）->GMap{
让mut-map:GMap=GMap{n:dim，省道：~[]}；
返回图
}
pub fn new_dart（&self，）->@dart{
让mut-dart=@dart{alpha:~[]，embed:~[]，taged:false}；
dart.alpha=vec:：from_elem（self.n+1，dart）；
//dart.embed=vec:：from_elem（self.n+1，）；
回程镖；
}
酒馆fn尺寸（和自身）->uint{
赛尔夫
}
}
//发布fn遍历（&self，[bool，…]）
枚举单元{
无效的
顶点，
边缘，
面对
固体
}   
fn main（）{
让topo:GMap=GMap:：new（3）；
}

问题在于可变性如何通过所有权继承。对于可变的东西，其所有者必须是可变的。所有权继承，除非通过新所有者继承，

@

和

&

被归类为所有者。因此，在本例中，

dart

拥有

@dart

框，但不拥有框中的内容，因此

x

上的

mut

并不意味着框中的内容是可变的（事实上，它是不可变的，因为它可能在引用它的其他对象的脚下发生变化）

解决这一问题的方法是，要么将该框设置为可变框，使dart结构的所有者是可变的，即

@mut dart{..}

（这有一个（小的）运行时惩罚，如果程序在借用时变为不可变，则可能使程序失败），要么一次性构建它。前者不是最优的，后者听起来很难实现。然而，前者可能看起来像：

struct Dart<T> {
    alpha: ~[@mut Dart<T>],
    embed: ~[@T],
   tagged: bool
}

// ...

    pub fn new_dart(&self, ) -> @mut Dart<T> {
        let dart = @mut Dart{alpha: ~[], embed: ~[], tagged: false};        
        dart.alpha = vec::from_elem(self.n + 1, dart); 
        //dart.embed = vec::from_elem(self.n + 1, );
        return dart;
    }

struct-Dart{
阿尔法：~[@mut-Dart]，
嵌入：~[@T]，
标签：布尔
}
// ...
pub fn new_dart（&self，）->@mut dart{
设dart=@mut-dart{alpha:~[]，embed:~[]，taged:false}；
dart.alpha=vec:：from_elem（self.n+1，dart）；
//dart.embed=vec:：from_elem（self.n+1，）；
回程镖；
}

---

（非

@mut

解决方案需要的是，但我不清楚如何让它在Rust中工作。）

这些就是我现在学习Rust而不是使用Haskell的原因。我发现图形结构从来都感觉不太正确，总是需要这些技巧。再次感谢您的帮助。我想我们需要letrec或lazy eval来解决这个问题。@MFlamer，有lazy eval via，但这是一个非常重要的解决方案。如果我将此添加到上面的函数“self.darts.push（dart）；”，该怎么办？因为这是一种针对结构的方法，在特定实例中可能是可变的，也可能不是可变的，所以Rust如何确定对self进行变异是否有效？@MFlamer，

&mut-self

可能也可以，并且稍微灵活一些。