标签: mutable

我在Haskell中寻找一个可变(平衡)树/ map/hash表,或者在函数内部如何模拟它.即,当我多次调用相同的函数时,结构将被保留.到目前为止,我已经尝试了Data.HashTable(可以,但有点慢)并尝试了Data.Array.Judy,但我无法使其与GHC 6.10.4一起使用.还有其他选择吗？

为什么在Python 2.6中不推荐使用MutableString类;
为什么它在Python 3中删除了？

我钦佩Python的一个原因是它区分了可变类型和不可变类型.在进入Python之前花了一段时间在c编程,我很惊讶Python如何轻松地消除指针解除引用的所有复杂性,这让我很生气.在Python中,一切都按照我期望的方式工作,我很快意识到可变/不可变的区别在其中起着重要作用.

当然还有一些皱纹(可变函数参数默认是一个值得注意的例子)但总的来说,我觉得可变/不可变的区别大大澄清了变量及其值是什么以及它们应该如何表现的问题.

但是它来自哪里？我必须假设GvR不是第一个设想这种区别的人,并且Python不是第一个使用它的语言.我有兴趣听听使用这个概念的早期语言,以及任何早期的理论讨论.

将collection.immutable.Set转换为collection.mutable.Set的最佳方法是什么？

该Bitmap班有一个方法copy()与下面的签名:

public Bitmap copy(Bitmap.Config config, boolean isMutable)

可变和不可变之间是否存在性能差异Bitmap？

在Java中,集合仅在插入时仅检查对象与已在集合中的对象的相等性.这意味着如果在对象已经存在于集合中之后,它变得等于集合中的另一个对象,则该集合将保持两个相等的对象而不会抱怨.

编辑:例如,考虑一个简单的对象,并假设hashCode和equals是按照最佳实践/定义的

class Foo {
    int foo;

    Foo(int a){ foo = a; }
    //+ equals and hashcode based on "foo"
}

Foo foo1 = new Foo(1);
Foo foo2 = new Foo(2);
Set<Foo> set = new HashSet<Foo>();
set.add(foo1);
set.add(foo2);
//Here the set has two unequal elements.
foo2.foo = 1;
//At this point, foo2 is equal to foo1, but is still in the set 
//together with foo1.

如何为可变对象设计一个集合类？我期望的行为如下:如果集合中的一个对象在任何时候变得等于集合中的另一个对象,则该集合中的该对象将被删除.有没有？是否有一种编程语言可以使这更容易实现？

A:

 Bitmap immutableBmp= BitmapFactory.decodeResource(getApplicationContext().getResources(),R.drawable.sample);
 mutableBitmap=immutableBmp.copy(Bitmap.Config.ARGB_8888, true);

B:

Bitmap immutableBmp= BitmapFactory.decodeFile(filePath);
mutableBitmap=immutableBmp.copy(Bitmap.Config.ARGB_8888, true);

C:

BitmapFactory.Options options = new BitmapFactory.Options();
options.inMutable=true;
myBitmap=BitmapFactory.decodeFile(filePath,options);

A作品,但B和C不.我试图将不可变位图转换为可变位图.它适用于资源图像,但不适用于文件图像.有什么问题？

鉴于可变结构通常被认为是邪恶的(例如,为什么可变结构"邪恶"？),是否有可能促使.NET框架的设计者制作System.Windows.Point和System.Windows.Vector变异的潜在好处？

我想理解这一点,所以我可以决定是否有必要使我自己的类似结构变得可变(如果有的话).做出决定Point和Vector变异可能只是判断错误,但如果有充分理由(例如,表现好处),我想了解它是什么.

我知道我偶然发现了Vector.Normalize()几次该方法的实现,因为它,惊喜(!),并没有带来新鲜感Vector.它只是改变了当前的向量.

我一直认为它应该像这样工作:

var vector = new Vector(7, 11);
var normalizedVector = vector.Normalize(); // Bzzz! Won't compile

但它实际上是这样的:

var vector = new Vector(7, 11);
vector.Normalize(); // This compiles, but now I've overwritten my original vector

......所以,似乎不变性只是为了避免混淆是一个好主意,但同样,也许在某些情况下值得存在这种混淆.

我知道Scala有var(对于可变状态)但是纯函数式编程不鼓励使用任何可变状态,而是专注于使用val所有东西.

来自一个势在必行的世界,很难放弃可变的状态.

我的问题是什么时候可以在你的Scala代码中使用var？所有代码都可以使用val完成.如果是,那么为什么Scala有变量呢？

我试图迭代地导航递归数据结构,以便在某个位置插入元素.根据我的有限理解,这意味着对结构的根进行可变引用,并通过对其跟随者的引用连续替换它:

type Link = Option<Box<Node>>;

struct Node {
    next: Link
}

struct Recursive {
    root: Link
}

impl Recursive {
    fn back(&mut self) -> &mut Link {
        let mut anchor = &mut self.root;
        while let Some(ref mut node) = *anchor {
            anchor = &mut node.next;
        }
        anchor
    }
}

(Rust操场链接)

但是,这失败了:

error[E0499]: cannot borrow `anchor.0` as mutable more than once at a time
  --> src/main.rs:14:24
   |
14 |         while let Some(ref mut node) = *anchor {
   |                        ^^^^^^^^^^^^
   |                        | …