标签: immutability

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

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

我正在使用相当多的不可变集合,我很好奇如何使用Gson对它们进行反序列化.由于没有人回答我自己找到了解决方案,我正在简化问题并提出自己的答案.

我有两个问题:

• 如何Deserializer为所有人写一个单一的工作ImmutableList<XXX>？
• 如何为所有人注册ImmutableList<XXX>？

我感兴趣的是一个在程序中用作引用表的Immutable DataFrame,在最初构造之后强制执行read_only属性(在我的情况下是在类def __init__()方法中).

我看到索引对象已冻结.

有没有办法使整个DataFrame不可变？

通过Immutable.js Map对象处理迭代的好方法是什么？这有效:

{stocks.map((stock,key)=>{
    return ( <h3>{key}</h3> )
})}

但在控制台中发出警告"warning.js:45警告:使用地图作为子节点尚未完全支持.这是一个可能被删除的实验性功能.将其转换为键控的ReactElements序列/迭代."

这已经在前面讨论了,这个链接提出了一些策略https://github.com/facebook/immutable-js/issues/667但它们对我来说似乎很笨拙.喜欢:

posts.entrySeq().map(o => 
     <Post value={o[1]} key={o[0]} />
)

工作但很笨拙的感觉.有更自然的方式吗？

在Python中,当你想使用列表作为某些字典的键时,你可以把它们变成元组,这些元组是不可变的,因此是可以删除的.

>>> a = {}
>>> a[tuple(list_1)] = some_value
>>> a[tuple(list_2)] = some_other_value

当您想要将set对象用作某些字典的键时,也会发生同样的情况- 您可以构建一个冷冻集,这也是不可变的,因此是可清除的.

>>> a = {}
>>> a[frozenset(set_1)] = some_value
>>> a[frozenset(set_2)] = some_other_value

但似乎对于字典没有等价物.

我想到的第一个想法(最终发现它很糟糕)是str(some_dict)用作关键.但是,字典总是使用不同的散列函数,因此相同字典的字符串可能不同.

是否有任何解决方法称为良好实践,或者是否有人有其他想法如何使用类字典对象作为其他词典的键？

虽然frozendict 被拒绝了,但是types.MappingProxyType在python 3.3中向公共API添加了一个相关的类.

我理解MappingProxyType的只是底层的一个包装dict,但尽管它在功能上并不等同于frozendict？

换句话说,原始PEP 416 frozendict与此之间的实质区别是什么:

from types import MappingProxyType
def frozendict(*args, **kwargs):
  return MappingProxyType(dict(*args, **kwargs))

当然MappingProxyType不是像现在这样可以清洗,但正如PEP所建议的那样frozendict,它可以在确保其所有值都是可清除之后可以使用(MappingProxyType不能被子类化,因此需要组合和转发方法).

如果我有一个非常不可变的类型(所有成员都是只读的,如果它们是引用类型成员,那么它们也引用了非常不可变的对象).

我想在类型上实现一个惰性初始化属性,如下所示:

private ReadOnlyCollection<SomeImmutableType> m_PropName = null;
public ReadOnlyCollection<SomeImmutableType> PropName
{
    get
    {
        if(null == m_PropName)
        {
            ReadOnlyCollection<SomeImmutableType> temp = /* do lazy init */;
            m_PropName = temp;
        }
        return m_PropName;
    }
}

据我所知:

m_PropName = temp; 

......是线程安全的.我并不担心两个线程同时竞争初始化,因为它很少见,从逻辑角度来看两个结果都是相同的,如果我没有,我宁愿不使用锁至.

这会有用吗？优缺点都有什么？

编辑: 谢谢你的回答.我可能会继续使用锁.但是,我很惊讶没有人提出编译器意识到临时变量是不必要的可能性,只是直接分配给m_PropName.如果是这种情况,则读取线程可能会读取尚未完成构造的对象.编译器是否会阻止这种情况？

(答案似乎表明运行时不会允许这种情况发生.)

编辑: 所以我决定使用由Joe Duffy撰写的这篇文章启发的Interlocked CompareExchange方法.

基本上:

private ReadOnlyCollection<SomeImmutableType> m_PropName = null;
public ReadOnlyCollection<SomeImmutableType> PropName
{
    get
    {
        if(null == m_PropName)
        {
            ReadOnlyCollection<SomeImmutableType> temp = /* do lazy init */;
            System.Threading.Interlocked(ref m_PropName, temp, null);
        }
        return …

在Scala我希望能够写

val petMap = ImmutableMultiMap(Alice->Cat, Bob->Dog, Alice->Hamster)

底层Map [Owner,Set [Pet]]应该同时具有Map和Set不可变.这是ImmutibleMultiMap与伴随对象的初稿:

import collection.{mutable,immutable}

class ImmutableMultiMap[K,V] extends immutable.HashMap[K,immutable.Set[V]]

object ImmutableMultiMap {
  def apply[K,V](pairs: Tuple2[K,V]*): ImmutableMultiMap[K,V] = {
    var m = new mutable.HashMap[K,mutable.Set[V]] with mutable.MultiMap[K,V]
    for ((k,v) <- pairs) m.addBinding(k,v)
    // How do I return the ImmutableMultiMap[K,V] corresponding to m here?
  }
}

你能优雅地解决评论线吗？地图和集合都应该是不可变的.

谢谢!

作为一个小练习,我在haskell中计算了以下单词计数程序.它计算文本文件中的不同单词,并输出50个最常用的单词及其频率.

import qualified Data.Map as Map
import Data.List.Split
import Data.List
import Data.Ord

-- Count words
count = Map.toList . foldl' increment Map.empty
    where
        increment dict k = Map.insert k (1 + Map.findWithDefault 0 k dict) dict

-- Sort the counts
countAndSort = sortBy (flip $ comparing snd) . count

-- Pretty printing
pp :: Show a => [(String,a)] -> IO()
pp = putStrLn . foldl' format "" where
    format text (x,y) = text ++ "\n" ++ x ++ "\t" ++ …

我正在尝试使用Scala以不可变的方式编写NSGA2中使用的Deb的快速非支配排序算法(NDS).

但问题似乎比我想象的要困难,所以我在这里简化了制作MWE的问题.

想象一下,一个群体Seq[A],每个A元素decoratedA都有一个列表,其中包含指向其他群体元素的指针Seq[A].

一个函数evalA(a:decoratedA)取linkedA它包含的列表,并减少每个的值.

接下来,我将获取decoratedAPopulation人口A 的子集列表,并对evalA每个人进行调用.我有一个问题,因为在这个子集列表上的元素的每次迭代之间decoratedAPopulation,我需要A用decoratedA新的更新linkedA它包含的新的更新它包含...

更有问题的是,每个人口元素都需要更新'linkedA'来替换链接元素,如果它发生变化......

你可以看到Hum,以这种方式保持所有链表同步似乎很复杂.我提出了另一个解决方案底部,可能需要递归才能在每个EvalA替换元素的新种群后返回.

我怎样才能以不变的方式正确地做到这一点？

以可变的方式编码很容易,但我找不到以不可变的方式做到这一点的好方法,你有路径或想法吗？

object test extends App{

  case class A(value:Int) {def decrement()= new A(value - 1)}

  case class decoratedA(oneAdecorated:A, listOfLinkedA:Seq[A])

  // We start algorithm loop with A element with value = 0
  val population = Seq(new A(0), new A(0), new A(8), new A(1))

  val decoratedApopulation = Seq(new …