我想指出F#中的"风险"部分.请考虑以下代码
let mutable a, b as ab = 0, 0
a <- 4
a
ab
你会得到a = 4和ab = 0, 0.这可能是一种正确的行为,我只想指出并了解你的意见.你觉得这种行为是否合乎逻辑,为什么？我有一些问题要接受它,因为我一直认为(a,b)和ab应该是相同的.
我正在尝试解决缺少的问题,collection.mutable.SortedSet这就是我的跳过列表实现.我几乎在那里:
import collection.{SortedSet => CSortedSet, SortedSetLike => CSortedSetLike}
import collection.mutable.{Set => MSet, SetLike => MSetLike}
import collection.generic.{MutableSetFactory, GenericCompanion}
object SkipList extends MutableSetFactory[SkipList] {
def empty[A](implicit ord: Ordering[A]): SkipList[A] = ???
}
trait SkipList[A] extends MSet[A] with MSetLike[A, SkipList[A]] with CSortedSet[A]
with CSortedSetLike[A, SkipList[A]] {
override def empty: SkipList[A] = SkipList.empty[A](ordering)
def rangeImpl(from: Option[A], until: Option[A]): SkipList[A] =
throw new Exception("Unsupported operation")
}
好的,这个编译.但与不可变排序集不同,我可以毫不含糊地做
case class Holder(i: Int) extends Ordered[Holder] {
def compare(b: Holder) = i.compare(b.i)
}
def test1(iss: …我不确定是使用可变结构还是可变类.我的程序存储了一个包含大量对象的数组.我注意到使用类会使所需的内存量翻倍.但是,我希望这些对象是可变的,并且我被告知使用可变结构是邪恶的.这就是我的类型:
struct /* or class */ Block
{
public byte ID;
public bool HasMetaData; // not sure whether HasMetaData == false or
// MetaData == null is faster, might remove this
public BlockMetaData MetaData; // BlockMetaData is always a class reference
}
像这样分配大量的对象(注意下面的两个代码都运行了81次):
// struct
Block[,,] blocks = new Block[16, 256, 16];
使用大约35 MiB的内存,同时这样做:
// class
Block[,,] blocks = new Block[16, 256, 16];
for (int z = 0; z < 16; z++)
for (int y = 0; y < 256; …我正在构建代码以获得理解,实际上是Solitaire求解器.我有一个简单的暴力实现,它使用状态monad,实际上只是为了证明我可以使用它(它只保留每个移动的计数).但是现在我想使用Unboxed Mutable数组来记录被访问的板,从而在我到达已经通过另一条路径访问的板位置时快速评估路径.似乎ST monad不允许我线程隐式状态,但是我必须使用ST(或IO)才能访问Mutable数组.因此,似乎我必须结合两个Monads - State来线程化状态(实际上包括一个Mutable数组),另一个(ST)来获得Mutable数组函数.
我一直在玩deepcopy功能和复制功能,我对它们都有同样的问题.这就像副本是一个引用(或指针)而不是正确的副本.我正在使用Python中的数据记录(类),也许它可能是..我给你看一个例子:
>>> import copy
>>> class player1:
... age = 23
... score = 1
>>> class player2:
... age = 14
... score = 2
>>> player3 = copy.deepcopy(player1)
我打印参数.
>>> print player1.age, player1.score
23 1
>>> print player2.age, player2.score
14 2
>>> print player3.age, player3.score
23 1
现在我在player1数据记录中增加score参数.
>>> player1.score += 3
然后我再次打印结果.
>>> print player1.age, player1.score
23 4
>>> print player2.age, player2.score
14 2
>>> print player3.age, player3.score
23 4
为什么玩家3会改变？我只是增加了player1中的参数,而不是player3.它是可变的而不是不可变的.
提前致谢.
我有以下几种情况:我在这里展示的是简单的代码形式,以澄清我的担忧:
public void callMe()
{
AtomicInteger howManyOdds = new AtomicInteger(0);
AtomicInteger howManyEvens = new AtomicInteger(0);
loopThrough(100,howManyOdds,howManyEvens);
System.out.println(howManyOdds.get()+" "+howManyEvens.get());
}
private void loopThrough(int counter,AtomicInteger howManyOdds,AtomicInteger howManyEvens)
{
for(int i = 1 ; i <= counter ;i++)
{
if(i%2 == 0)
howManyEvens.getAndAdd(1);
else
howManyOdds.getAndAdd(1);
}
}
我知道它可以通过int[]但它看起来有点奇怪.在这种情况下,AtomicInteger是Mutable Integer的良好替代品吗？如果不是那么为什么？
好吧，我最近开始在Rust中编程，我需要帮助。这是我的代码。它应该引用分配给int的堆并更改其值。
let mut boxed_int = box 5;
let _ref_to_int = &mut *boxed_int; // why it is &int ???
*_ref_to_int = 10;
let mut boxed_int = box 5;
let _ref_to_int = &mut boxed_int;
*_ref_to_int = box 10;
最后一行会从堆中删除5并在同一地址分配10吗？或5不被删除，现在指针指向堆上另一个值为10的地址
请考虑以下代码:
case class Vector3(var x: Float, var y: Float, var z: Float)
{
def add(v: Vector3): Unit =
{
this.x += v.x
this.y += v.y
this.z += v.z
}
}
如你所见,case class持有可变状态.这样做是非常沮丧的,通常我同意并且绝对坚持这个"规则",但这里讲的是整个故事.
我正在使用Scala 从头开始编写一个小型3D游戏引擎.所以首先我考虑使用(更多)功能样式,但垃圾收集器会过于频繁.
想一想:我在测试游戏中有几十个实体.所有这些都有一个位置(Vector3),一个方向(Vector3),一个比例(Vector3)和一大堆矩阵.如果我要在这些类(Vector3和Matrix4)中运行并使它们不可变,我会每帧返回数百个新对象,导致巨大的fps损失,因为,让我们面对它,GC有其用途,但在游戏引擎和OpenGL ......不是那么多.
Vector3之前是一个类,但它现在是一个case类,因为代码中的某个地方我需要模式匹配.
那么,使用保持可变状态的案例类真的那么糟糕吗？
请不要不把它变成一个关于讨论"为什么你甚至可以使用Scala开发等项目吗？" 我知道可能有更好的替代方案,但我对用C++编写(又一个)引擎不感兴趣,我也不太愿意潜入Rust(还).
我想创建一个键为整数且值为可变Set的Map对象。但是，当我从GroupBy函数创建Map对象时，可变集合中的值无法再更改。谁能告诉我为什么会这样？
import scala.collection.mutable
val groupedMap: Map[Int, mutable.Set[Int]] =
List((1,1),(1,2),(2,3))
.groupBy(_._1)
.mapValues(_.map(_._2).to[mutable.Set])
val originalMap: Map[Int, mutable.Set[Int]] =
Map(1 -> mutable.Set(1, 2), 2 -> mutable.Set(3))
println(groupedMap) // Map(1 -> Set(1, 2), 2 -> Set(3))
println(originalMap) // Map(1 -> Set(1, 2), 2 -> Set(3))
groupedMap(1) += 99
originalMap(1) += 99
println(groupedMap) // Map(1 -> Set(1, 2), 2 -> Set(3)) <- HERE IS THE PROBLEM, THE VALUE 99 CAN NOT BE ADDED TO MY MUTABLE SET!
println(originalMap) // Map(1 -> Set(99, 1, …