标签: mutability

如何在不创建其他变量的情况下处理此错误？

func reduceToZero(x:Int) -> Int {
    while (x != 0) {
        x = x-1            // ERROR: cannot assign to 'let' value 'x'
    }
    return x
}

我不想创建额外的变量来存储x的值.甚至可以做我想做的事情吗？

我遇到了一个问题,我必须存储一个时刻对象的初始值,但是我遇到了一些问题,我阻止了我的变量与原始对象一起变化.

不幸的是,Object.freeze()不起作用,因为当我尝试格式化时,moment.js返回"无效日期"错误.

我的理解是Python字符串是不可变的.

我尝试了以下代码:

a = "Dog"
b = "eats"
c = "treats"

print a, b, c
# Dog eats treats

print a + " " + b + " " + c
# Dog eats treats

print a
# Dog

a = a + " " + b + " " + c
print a
# Dog eats treats
# !!!

Python不应该阻止这项任务吗？我可能错过了一些东西.

任何的想法？

在Google Go中,我读到字符串是不可变的,好吧但是是int？其他类型呢？作为一个稍微老一点的程序员,我更喜欢可变性,即使我知道不变性的好处,我更喜欢生活危险.

知道哪些类型是可变的或不可变的将是非常有帮助的.

更新,我最关心的是实际问题取决于类型是可变的还是不可变的.与Java中的典型示例一样,如果在循环中创建一个String并循环10,000次,则将创建10,000个String,然后进行垃圾回收.在我工作的公司的项目中,这实际上是一个严重的问题.

问题是,Go的不变性在某些情况下会导致同样的问题吗？

它会影响你应该如何对待var.(或者我认为它确实如此).

再次更新,我也关注其他实际问题.知道某些东西是不可变的意味着我可以编写并行的代码,并且对该对象的一个​​引用的更新不应该更新其他引用.但有时候我想做危险的事情,我想要变性.

这些是可变性与不变性的结果,并影响我如何编写代码.

我有以下代码:

extern crate rand;

use rand::{thread_rng, Rng};

fn main() {
    let mut vec: Vec<u32> = (0..10).collect();
    let mut slice: &[u32] = vec.as_mut_slice();

    thread_rng().shuffle(slice);
}

并得到以下错误:

error[E0308]: mismatched types
 --> src/main.rs:9:26
  |
9 |     thread_rng().shuffle(slice);
  |                          ^^^^^ types differ in mutability
  |
  = note: expected type `&mut [_]`
             found type `&[u32]`

我想我明白向量和切片的内容是不可变的,这会导致错误,但我不确定.

签名as_mut_slice是pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T],所以切片应该是可变的,但它不知何故.

我知道必须有一个简单的解决办法,但我尽我所能,无法让它发挥作用.

我在这里主要谈论Python,但我想这可能适用于大多数语言.如果我有一个可变对象,那么进行就地操作也是一个坏主意还会返回该对象吗？似乎大多数示例只是修改对象并返回None.例如,list.sort.

我有一个内部可变性的结构.

use std::cell::RefCell;

struct MutableInterior {
    hide_me: i32,
    vec: Vec<i32>,
}
struct Foo {
    //although not used in this particular snippet,
    //the motivating problem uses interior mutability
    //via RefCell.
    interior: RefCell<MutableInterior>,
}

impl Foo {
    pub fn get_items(&self) -> &Vec<i32> {
        &self.interior.borrow().vec
    }
}

fn main() {
    let f = Foo {
        interior: RefCell::new(MutableInterior {
            vec: Vec::new(),
            hide_me: 2,
        }),
    };
    let borrowed_f = &f;
    let items = borrowed_f.get_items();
}

产生错误:

error[E0597]: borrowed value does not live long enough
  --> …

这在任何语言中都应该是一项微不足道的任务.这不适用于Rust.

use std::collections::HashMap;

fn do_it(map: &mut HashMap<String, String>) {
    for (key, value) in map {
        println!("{} / {}", key, value);
        map.remove(key);
    }
}

fn main() {}

这是编译器错误:

error[E0382]: use of moved value: `*map`
 --> src/main.rs:6:9
  |
4 |     for (key, value) in map {
  |                         --- value moved here
5 |         println!("{} / {}", key, value);
6 |         map.remove(key);
  |         ^^^ value used here after move
  |
  = note: move occurs because `map` has type `&mut std::collections::HashMap<std::string::String, std::string::String>`, which does …

我想比较Scala中的immutable.Map和mutable.Map的性能特征,以进行类似的操作(即将许多映射合并为一个映射.请参阅此问题).我有可变和不可变映射的类似实现(见下文).

作为测试,我生成了一个包含1,000,000单项Map [Int,Int]的List,并将此列表传递给我正在测试的函数.有了足够的内存,结果就不足为奇了:对于mutable.Map来说是~1200ms,对于immutable.Map来说是~1800ms,对于使用mutable.Map的命令式实现来说是~750ms - 不知道是什么导致了那里的巨大差异,但是随意对此也有评论.

让我感到惊讶的是,也许是因为我有点厚,是因为IntelliJ 8.1中的默认运行配置,两个可变实现都遇到了OutOfMemoryError,但是不可变集合没有.不可变测试确实完成了,但它的速度非常慢 - 大约需要28秒.当我增加最大JVM内存(大约200MB,不确定阈值在哪里)时,我得到了上面的结果.

无论如何,这是我真正想知道的:

为什么可变实现耗尽内存,但不可变实现却没有？ 我怀疑不可变版本允许垃圾收集器在可变实现之前运行并释放内存 - 并且所有这些垃圾收集都解释了不可变低内存运行的缓慢 - 但我想要更详细的解释比起那个来说.

以下实施.(注意:我并未声称这些是可能的最佳实现.请随意提出改进建议.)

  def mergeMaps[A,B](func: (B,B) => B)(listOfMaps: List[Map[A,B]]): Map[A,B] =
    (Map[A,B]() /: (for (m <- listOfMaps; kv <-m) yield kv)) { (acc, kv) =>
      acc + (if (acc.contains(kv._1)) kv._1 -> func(acc(kv._1), kv._2) else kv)
    }

  def mergeMutableMaps[A,B](func: (B,B) => B)(listOfMaps: List[mutable.Map[A,B]]): mutable.Map[A,B] =
    (mutable.Map[A,B]() /: (for (m <- listOfMaps; kv <- m) yield kv)) { (acc, kv) =>
      acc + (if (acc.contains(kv._1)) kv._1 …

首先,让代码说:

#[derive(Debug)]
struct Bar;

#[derive(Debug)]
struct Qux {
    baz: bool
}

#[derive(Debug)]
struct Foo {
    bars: Vec<Bar>,
    qux: Qux,
}

impl Foo {
    fn get_qux(&mut self) -> &mut Qux {
        &mut self.qux
    }

    fn run(&mut self) {
        // 1. Fails:
        let mut qux = self.get_qux();

        // 2. Works:
        // let mut qux = &mut Qux { baz: false };

        // 3. Works:
        // let mut qux = &mut self.qux;

        let qux_mut = &mut qux;
        qux_mut.baz = true;

        for bar in …