Question

我有一个返回Result＆lt;＆amp;'a~Foo，BarErr＆gt;的函数，我可以使用它来访问：

match x.borrow() {
  Ok(ref foo) => println!("Found {}", foo.value),
  Err(Nope) => println!("Bleh")
}

然而，我发现自己现在处于一个更复杂的情况，我希望借用一个可变引用，这样我就可以在其上调用一个函数：

match x.borrow() {
  Ok(ref foo) => { foo.inc(); trace!("Found {}", foo.value); },
  Err(Nope) => trace!("Bleh")
}

我已经尝试了一些我需要坚持“mut”的变体，例如mut ref foo，ref mut foo， - ＆gt; mut结果＆lt; ...＆gt;， - ＆gt;结果，但我似乎无法弄清楚所需的语法。

我一直在：

error: cannot borrow immutable dereference of `~`-pointer `***foo` as mutable

它应该是什么？

完整的代码示例：

macro_rules! trace(
  ($($arg:tt)*) => (
    { let x = ::std::io::stdout().write_line(format_args!(::std::fmt::format, $($arg)*)); println!("{}", x); }
  );
)

#[deriving(Show)]
struct Foo {
  value: int
}

impl Foo {
  fn inc(&mut self) {
    self.value += 1;
  }
}

#[deriving(Show)]
struct Bar {
  data: Option<~Foo>
}

#[deriving(Show)]
enum BarErr {
  Nope
}

impl Bar {
  fn borrow<'a>(&'a mut self) -> Result<&'a ~Foo, BarErr> {
    match self.data {
      Some(ref e) => return Ok(e),
      None => return Err(Nope)
    }
  }
}

#[test]
fn test_create_indirect() {
  let y = ~Foo { value: 10 };
  let mut x = Bar { data: Some(y) };
  let mut x2 = Bar { data: None };
  {
    match x.borrow() {
      Ok(ref mut foo) => { foo.inc(); trace!("Found {}", foo.value); },
      Err(Nope) => trace!("Bleh")
    }
  }
  {
    let z = x2.borrow();
    trace!("Z: {}", z);
  }
}

Answer 1

问题是引用不拥有数据，因此它们的可变性是继承的。您无法将&'a转换为&'a mut，因为该引用下的数据是不可变的。

您必须返回Result<&'a mut ~Foo, BarErr>才能达到您想要的效果：

impl Bar {
  fn borrow<'a>(&'a mut self) -> Result<&'a mut ~Foo, BarErr> {
    match self.data {
      Some(ref mut e) => return Ok(e),
      None => return Err(Nope)
    }
  }
}

#[test]
fn test_create_indirect() {
  let y = ~Foo { value: 10 };
  let mut x = Bar { data: Some(y) };
  let mut x2 = Bar { data: None };
  {
    match x.borrow() {
      Ok(foo) => { foo.inc(); trace!("Found {:?}", foo.value); },
      Err(Nope) => trace!("Bleh")
    }
  }
  {
    let z = x2.borrow();
    trace!("Z: {:?}", z);
  }
}

请注意，在使用网站上，我将x.borrow()与Ok(foo)匹配，而不是Ok(ref mut foo)。这没关系，因为foo本身就是&mut，因此您可以通过它访问&mut self方法。

你如何在生锈中借用一个可变指针？

1 个答案: