标签: mutable

这就是我到目前为止所拥有的.

let Swap (left : int , right : int ) = (right, left)

let mutable x = 5
let mutable y = 10

let (newX, newY) = Swap(x, y) //<--this works

//none of these seem to work
//x, y <- Swap(x, y)
//(x, y) <- Swap(x, y)
//(x, y) <- Swap(x, y)
//do (x, y) = Swap(x, y)
//let (x, y) = Swap(x, y)
//do (x, y) <- Swap(x, y)
//let (x, y) <- Swap(x, y)

我在假设,如果你有一个包含一个Java集<>内(或在地图<>对于这个问题的关键)的对象,所使用的任何字段,以确定身份或关系(通过纠正hashCode(),equals(),compareTo()等.)如果不对集合上的操作造成未指定的行为,则无法更改？(编辑:在其他问题中提到)

(换句话说,这些字段应该是不可变的,或者您应该要求从集合中删除对象,然后更改,然后重新插入.)

我问的原因是我正在阅读Hibernate Annotations参考指南,它有一个例子,其中有一个HashSet<Toy>但是Toy类有字段name并且serial是可变的并且也用于hashCode()计算......一个红旗在我脑海中消失了我只想确保理解它的含义.

我发布了与我的标题相同的上一个问题(我认为)同样的问题,但代码中还有其他问题.我无法确定该案件是否与我的相同.

无论如何,我想替换列表中列表中的元素.码:

myNestedList = [[0,0]]*4 # [[0, 0], [0, 0], [0, 0], [0, 0]]
myNestedList[1][1] = 5

我现在期待:

[[0, 0], [0, 5], [0, 0], [0, 0]]

但我得到:

[[0, 5], [0, 5], [0, 5], [0, 5]]

为什么？

这在命令行中复制.在Linux2上的Python 3.1.2(r312:79147,2010年4月15日,15:35:48)[GCC 4.4.3]

这个问题真的是这个问题的一个分支,但我认为它应该得到自己的答案.

根据ECMA-334第15.13节(关于using声明,以下称为资源获取):

在资源获取中声明的局部变量 是只读的,并且应包括初始化器.如果嵌入语句试图修改这些局部变量(通过赋值或发生编译时间错误++和--操作员)或它们传递作为ref或out 参数.

这似乎解释了为什么下面的代码是非法的.

struct Mutable : IDisposable
{
    public int Field;
    public void SetField(int value) { Field = value; }
    public void Dispose() { }
}

using (var m = new Mutable())
{
    // This results in a compiler error.
    m.Field = 10;
}

但是这个怎么样？

using (var e = new Mutable())
{
    // This is doing exactly the same thing, but …

Scala既有可变的也有不可变的Map,但它只有一个不可变的List.如果你想要一个可变列表,你需要一个ListBuffer.

我不明白为什么会这样.有谁知道？.

我有一个项目,我想在关系数据库(Postgres)中存储一个大型结构(嵌套对象).它是一个更大的结构的一部分,我并不真正关心序列化格式 - 我很高兴它成为一个专栏中的blob - 我只是希望能够相当快地持久化并恢复它.

为了我的目的,SQLAlchemy PickleType主要完成这项工作.我遇到的问题是,我希望脏检查能够工作(可以使用Mutable Types).我希望他们不仅可以在路径中更改信息,而且还可以在边界中更改信息(更换层次).

class Group(Base):
    __tablename__ = 'group'

    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    paths = Column(types.PickleType)

class Path(object):
    def __init__(self, style, bounds):
        self.style = style
        self.bounds = bounds

class Bound(object):
    def __init__(self, l, t, r, b):
        self.l = l
        self.t = t
        self.r = r
        self.b = b

# this is all fine
g = Group(name='g1', paths=[Path('blah', Bound(1,1,2,3)),
                            Path('other_style', Bound(1,1,2,3)),])
session.add(g)
session.commit()

# so is this
g.name = 'g2'
assert g in …

我想在堆栈上创建一个可变结构,并从辅助函数中改变它.

#[derive(Debug)]
struct Game {
    score: u32,
}

fn addPoint(game: &mut Game) {
    game.score += 1;
}

fn main() {
    let mut game = Game { score: 0 };

    println!("Initial game: {:?}", game);

    // This works:
    game.score += 1;

    // This gives a compile error:
    addPoint(&game);

    println!("Final game:   {:?}", game);
}

试图编译这个给出:

error[E0308]: mismatched types
  --> src/main.rs:19:14
   |
19 |     addPoint(&game);
   |              ^^^^^ types differ in mutability
   |
   = note: expected type `&mut Game`
              found type `&Game`

我究竟做错了什么？

我有一个类(A),它有一个struct变量(S).在这个类的一个函数中,我在struct变量上调用一个mutating函数,这个函数需要一个闭包.此闭包的主体检查struct变量的name属性.

结构的变异函数依次调用某个类(B)的函数.这个类的函数再次关闭.在这个闭包的主体中改变结构,即更改name属性,并调用第一个类提供的闭包.

当我们检查struct的name属性时调用第一个类(A)闭包时,它永远不会被更改.

但是在第2步中,如果我使用结构(C)而不是类B,我会看到内部类A的闭包结构实际上已经改变了.以下是代码:

class NetworkingClass {
  func fetchDataOverNetwork(completion:()->()) {
    // Fetch Data from netwrok and finally call the closure
    completion()
  }
}

struct NetworkingStruct {
  func fetchDataOverNetwork(completion:()->()) {
    // Fetch Data from netwrok and finally call the closure
    completion()
  }
}

struct ViewModelStruct {

  /// Initial value
  var data: String = "A"

  /// Mutate itself in a closure called from a struct
  mutating func changeFromStruct(completion:()->()) {
    let networkingStruct = NetworkingStruct()
    networkingStruct.fetchDataOverNetwork {
      self.data = "B"
      completion()
    }
  } …

谁能帮我解决这个问题？

ImportError: dlopen(/Users/......./venv/lib/python3.6/site-packages/recordclass/mutabletuple.cpython-36m-darwin.so, 2): Symbol not found: __PyEval_GetBuiltinId
  Referenced from: /Users/......./venv/lib/python3.6/site-packages/recordclass/mutabletuple.cpython-36m-darwin.so
  Expected in: flat namespace
 in /Users/......../venv/lib/python3.6/site-packages/recordclass/mutabletuple.cpython-36m-darwin.so

我正在使用 Mac（如果有相关的话）

我发现了一个我可以理解的可变集的奇怪行为:

我有一个对象,我想添加到一个集合.该类的equals方法被覆盖.当我向set添加两个不同的对象时,它为equals方法产生相同的输出,我在contains方法的可变和不可变集之间得到了不同的行为.

这是代码片段:

class Test(text:String){
  override def equals(obj:Any) = obj match {
    case t: Test => if (t.text == this.text) true else false
    case _ => false
  }
  override def toString = text
}

val mutableSet:scala.collection.mutable.Set[Test] = scala.collection.mutable.Set.empty
mutableSet += new Test("test")
println(mutableSet)
println(mutableSet.contains(new Test("test")))

val immutableSet:scala.collection.immutable.Set[Test] = scala.collection.immutable.Set.empty
immutableSet += new Test("test")
println(immutableSet)
println(immutableSet.contains(new Test("test")))

这产生了输出:

Set(test)
false
Set(test)
true

在我看来,contains的两个调用应该产生相同的输出(true).

任何人都可以帮助我理解这里的区别,或者这是scala不可变集实现中的错误吗？顺便说一句,我使用scala 2.8.1.final

谢谢.