标签: mutable

为什么或为什么不能在C++中声明类成员变量static mutable？就像是

static mutable int t; //This won't compile

对我来说,没有理由禁止这种声明.例如,出于维护全局类范围统计的原因,可以方便地使用可由(逻辑上)const方法改变的静态变量.所以要么这在C++中是一种错误设计而且不必要地复杂化,或者有一个我看不到的实际或理论上的原因.

我试图返回一个带有until循环的可变序列,但是我有一个不可变的seq返回(0到nbGenomes):

 def generateRandomGenome(nbGenomes:Int): IndexedSeq[GenomeDouble]={
    return ((0 until nbGenomes toSeq).map{e => generateRandomGenome}) 
  }

返回编译错误:

found   : scala.collection.immutable.IndexedSeq[org.openmole.tools.mgo.mappedgenome.genomedouble.GenomeDouble]
 required: scala.collection.mutable.IndexedSeq[org.openmole.tools.mgo.mappedgenome.genomedouble.GenomeDouble]
    return ((0 until nbGenomes toSeq).map{e => generateRandomGenome}) 

我如何强制until循环返回一个可变的seq？谢谢scala社区!

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

我有一个对象,我想添加到一个集合.该类的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

谢谢.

我正在写一个玩游戏的ai(aichallenge.org - Ants),它需要大量更新,并引用数据结构.我已经尝试了数组和地图,但基本问题似乎是每次更新都会创建一个新值,这会让它变慢.如果您花费超过一秒钟来进行移动,游戏会引导您,因此应用程序将被视为"硬实时".是否有可能在Haskell中具有可变数据结构的性能,或者我应该学习Python,还是在OCaml中重写我的代码？

我完全改写了蚂蚁"初学者包".从阵列更改为地图,因为我的测试显示地图更新速度更快.

我运行了地图版本并进行了分析,结果显示仅有20%的时间是由地图更新单独进行的.

这是一个简单的演示,说明阵列更新的速度有多慢.

slow_array =
    let arr = listArray (0,9999) (repeat 0)
        upd i ar = ar // [(i,i)]
    in  foldr upd arr [0..9999]

现在评估slow_array!9999需要将近10秒!虽然一次应用所有更新会更快,但该示例模拟了每回合必须更新阵列的真正问题,并且最好每次在计划下一轮时选择移动.

感谢nponeccop和Tener参考矢量模块.以下代码等同于我的原始示例,但运行时间为0.06秒而不是10秒.

import qualified Data.Vector.Unboxed.Mutable as V

fast_vector :: IO (V.IOVector Int)
fast_vector = do
  vec <- V.new 10000
  V.set vec 0
  mapM_ (\i -> V.write vec i i) [0..9999]
  return vec

fv_read :: IO Int
fv_read  = do
  v <- fast_vector
  V.read v 9999

现在,将其纳入我的蚂蚁代码......

具体来说,当我使用带有JSONkit的AFNeworking发出请求并且接收到嵌套了几个数组和字典的(id)JSON时,这个问题就出现了.

如果我不想修改数据,我没有任何问题:

self.myNSArray = [JSON objectForKey:@"result"];

但是如果我想修改数据,我必须将它存储在一个可变变量中:

self.myNSMutableArray = [[JSON objectForKey:@"result"] mutableCopy];

最后一个不会将嵌套数组或字典转换为可变数据; 它只适用于第一级.

我找到的唯一方法是在这个链接上递归可变对象 ; 但我不知道是否有解决此类问题的最佳方法.

提前致谢.

我对修改元组成员有点困惑.以下不起作用:

>>> thing = (['a'],)
>>> thing[0] = ['b']
TypeError: 'tuple' object does not support item assignment
>>> thing
(['a'],)

但这确实有效:

>>> thing[0][0] = 'b'
>>> thing
(['b'],)

还有效:

>>> thing[0].append('c')
>>> thing
(['b', 'c'],)

不起作用,并且有效(嗯？!):

>>> thing[0] += 'd'
TypeError: 'tuple' object does not support item assignment
>>> thing
(['b', 'c', 'd'],)

看似与以前相同,但有效:

>>> e = thing[0]
>>> e += 'e'
>>> thing
(['b', 'c', 'd', 'e'],)

那么,当你能够并且不能修改元组内的某些内容时,游戏的规则到底是什么？它似乎更像禁止使用赋值成员的赋值运算符,但最后两个案例让我感到困惑.

如果我有一个看起来像这样的方法:

- (NSDictionary *)removeDataInDictionary:(NSDictionary *)dictionary {

    NSMutableDictionary *mutableDictionary = [dictionary mutableCopy];
    [mutableDictionary removeObjectForKey:@"key"];

    // Return option 1
    return [NSDictionary dictionaryWithDictionary:mutableDictionary];

    // Return option 2
    return (NSDictionary *) mutableDictionary;
}

选项1是否"更好"代码化,因为它真的会返回一个while NSDictionary选项2实际上会NSMutableDictionary伪装成一个NSDictionary？

处理(否则)包含C++ 11随机类的随机生成器调用的常量函数的正确方法是什么？您是否应该放弃函数的常量标志,还是将生成器和分布声明为类的可变元素？一个最小的例子(不编译)可能是:

#include <random>

class foo 
{
  std::mt19937 MyGenerator;
  std::normal_distribution<precision_type> gauss;
  double get_rnd() const {return gauss(MyGenerator);}
};

我想通过这样的设置有接口操纵从FFI某种类型的结构STArray或STRef在ST单子.我会和供种作为此结构(如有用的操作的理解名字我自己的具体方法readArray和writeArray数组).

实现这个的最简单方法是什么？

STArray(基于https://hackage.haskell.org/package/base-4.7.0.2/docs/src/GHC-Arr.html)的实现对于那些不了解用于此目的的特殊GHC技术的人来说看起来太复杂了. .

我可以在一个更简单,可理解的Haskell级别上写一些东西吗？

备注

我不是在询问如何通过FFI访问结构.

我宁愿写getter和setter函数在C,我想反映他们在Haskell(获得ST-操作,如readArray和writeArray).

关于轻松声明这种界面的一些想法(可能的GHC扩展？)

如果我没有弄错的话,我可以将外来函数声明为IO动作或纯粹(如果我确定它是纯粹的).我理解后者只是简单地包装它unsafePerformIO:

foreign import ccall safe "getValue.h getValue" effect :: CInt -> Ptr CChar
foreign import ccall safe "getValue.h getValue" pure :: CInt -> IO (Ptr CChar)

因此,出现了这样的想法:"效果"和"纯粹"之间的中间形式是可能的,以节省程序员的工作."效果"限于"有限状态":

foreign import ccall safe "getValue.h writeValue" writeValue :: (ValueRef s) -> Value -> ST s () -- modeled after writeSTRef

除了GHC中此功能的标准两种变体外: …

fn main() {
    // block1: fails
    {
        let mut m = 10;

        let n = {
            let b = &&mut m;
            &**b // just returning b fails
        };

        println!("{:?}", n);
    }

    // block2: passes
    {
        let mut m = 10;

        let n = {
            let b = &&m;
            &**b // just returning b fails here too
        };

        println!("{:?}", n);
    }
}

block1因错误而失败:

error[E0597]: borrowed value does not live long enough
  --> src/main.rs:7:22
   |
7  |             let b …