标签: mutable

我正在使用scala 2.9.1,当我尝试这段代码时:

import scala.collection.mutable
val a = mutable.Set(1,2,3,4,7,0,98,9,8)
a.foreach(x => { println(x); a.remove(x) })

结果是这样的

0
98
2
1
4
3
8

没有列出a的所有元素.在此之后,a变为Set(9,7)而不是空集.它对我来说看起来很奇怪,它是一个bug还是我们在做foreach时无法修改集合本身？

假设我有一个非常简单的数据类型:

class SimpleObject:
    def __init__(self, property):
        self.property = property

    def update_property(self, value):
        self.property = value

我是一种特殊的列表来存储数据类型:

class SimpleList(collections.MutableSequence):
    def update_useful_property_of_list(self, value):
        self.useful_property_of_list = value

我存储它们:

simple1 = SimpleObject(1)
simple2 = SimpleObject(2)

simple_list = SimpleList([simple1, simple2])

有没有办法让SimpleList对象知道其成员的某个属性何时发生变化？例如,当这样的事情发生时,我怎样才能simple_list执行self.update_useful_property_of_list():

simple1.update_property(3)

对于Froto项目(F#中的Google Protobuf),我试图将反序列化代码从使用'a ref对象更新为传递值byref<'a>,以提高性能.

但是,下面的代码失败了hydrator &element field:

type Field = TypeA | TypeB | Etc

let hydrateRepeated
        (hydrator:byref<'a> -> Field -> unit)
        (result:byref<'a list>)
        (field:Field) =
    let mutable element = Unchecked.defaultof<'a>
    hydrator &element field
    result <- element :: result

错误FS0421:此时不能使用变量'element'的地址

有什么办法可以让代码在不改变hydrator参数签名的情况下工作吗？

我非常清楚我可以使用hydrator:'a ref -> Field -> unit并开始工作.但是,目标是支持反序列化为record类型,而无需ref在每次反序列化记录时在堆上创建一堆对象.

请注意,以下代码完全合法,并且与hydrator上面的函数声明具有相同的签名,因此我不清楚问题是什么.

let assign (result:byref<'a>) (x:'a) =
    result <- x

let thisWorks() =
    let mutable v = …

有没有办法检查一个类型是可变的还是不可变的？这个检查是否可以在编译时完成(即将分支if ismutable(T)编译为仅使用代码路径进行可变性或不变性)？

我安装了Rust 1.13并试过:

fn main() {
    let x: u32;
    x = 10; // no error?
}

当我编译这个文件时有一些警告,但是没有错误.因为我不声明x作为mut,不应该x = 10;导致错误？

为什么MobX鼓励在文档中使用可变对象？

但是，我看到了有关MobX的教程：http ://orlandohamsho.com/javascript/mobx-react-tutorial-building-first-application/

而且，他在教程中使用了不变的方法，而不是使用可变方法（参见下文）。

@action setUsers = (users) => { this.users = [...users]; （而不是推动它）

我也认为不变性方法更好（这样React.PureComponent可以工作，这意味着优化性能）

为什么MobX鼓励对对象进行变异？我应该使用哪种方法？

我正在实施IEquatable<T>，但我很难就可变GetHashCode类的覆盖达成共识。

以下资源都提供了一个实现，GetHashCode如果对象发生更改，则在对象的生命周期内将返回不同的值：

• /sf/answers/973428781/
• https://csharp.2000things.com/tag/iequatable/
• http://broadcast.oreilly.com/2010/09/understanding-c-equality-iequa.html

但是，此链接指出GetHashCode不应为可变类型实现，因为如果对象是集合的一部分，则可能会导致不良行为（这也一直是我的理解）。

有趣的是，MSDN 示例实现了GetHashCode仅使用不可变属性，这符合我的理解。但我很困惑为什么其他资源不涵盖这一点。他们真的错了吗？

如果一个类型根本没有不可变属性，编译器会GetHashCode在我重写时警告该类型丢失Equals(object)。在这种情况下，我应该实现它并只调用base.GetHashCode()或禁用编译器警告，还是我错过了某些内容并且GetHashCode应该始终被覆盖和实现？事实上，如果建议不GetHashCode应该为可变类型实现，为什么还要为不可变类型实现呢？与默认实现相比，它只是为了减少冲突GetHashCode，还是实际上添加了更多有形的功能？

总结我的问题，我的困境是，GetHashCode在可变对象上使用意味着如果对象的属性发生变化，它可以在对象的生命周期内返回不同的值。但不使用它意味着比较可能等效的对象的好处会丢失，因为它将始终返回唯一值，因此集合将始终回退到使用Equals其操作。

输入此问题后，“类似问题”框中弹出了另一个问题，似乎涉及同一主题。答案似乎非常明确，因为在GetHashCode实现中只应使用不可变属性。如果没有，那就干脆不写。Dictionary<TKey, TValue>尽管不是 O(1) 性能，但仍然可以正常运行。

我lru_cache在返回可变对象的函数上使用 Python ，如下所示：

import functools

@functools.lru_cache()
def f():
    x = [0, 1, 2]  # Stand-in for some long computation
    return x

如果我调用这个函数，改变结果并再次调用它，我不会获得一个“新鲜”的、未改变的对象：

a = f()
a.append(3)
b = f()
print(a)  # [0, 1, 2, 3]
print(b)  # [0, 1, 2, 3]

我明白为什么会发生这种情况，但这不是我想要的。解决方法是让调用者负责使用list.copy：

a = f().copy()
a.append(3)
b = f().copy()
print(a)  # [0, 1, 2, 3]
print(b)  # [0, 1, 2]

但是我想在里面解决这个问题f。一个漂亮的解决方案是这样的

@functools.lru_cache(copy=True)
def f():
    ...

尽管copy实际上没有任何参数被functools.lru_cache.

关于如何最好地实现这种行为的任何建议？

编辑

根据holdenweb 的回答，这是我的最终实现。 …

我试图修改函数内字符串的值，如下所示：

>>> def appendFlag(target, value):
...     target += value
...     target += " "
...
>>> appendFlag
<function appendFlag at 0x102933398>
>>> appendFlag(m,"ok")
>>> m
''

好吧，似乎“目标”仅在函数内更改，但是如何使新值在函数外可行？谢谢。

在 Python 中处理可变默认参数的方法是将它们设置为 None。

例如：

def foo(bar=None):
    bar = [] if bar is None else bar
    return sorted(bar)

如果我输入函数定义，那么唯一的类型 forbar说的bar是Optional，很明显，它不是Optional我期望sorted在其上运行该函数的时间：

def foo(bar: Optional[List[int]]=None):
    bar = [] if bar is None else bar
    return sorted(bar) # bar cannot be `None` here

那么我应该投吗？

def foo(bar: Optional[List[int]]=None):
    bar = [] if bar is None else bar
    bar = cast(List[int], bar) # make it explicit that `bar` cannot be `None`
    return sorted(bar) …