The immutable hierarchy doesn&#39;t contain a MultiMap, so you won&#39;t be able to use the converted structure with the same convenient syntax.  But if you&#39;re happy to deal with key/valueset pairs, then:

If you just want a mutable `HashMap`, you can just use `x.toMap` in 2.8 or `collection.immutable.Map(x.toList: _*)` in 2.7.

But if you want the whole structure to be immutable--including the underlying set!--then you have to do more: you need to convert the sets along the way.  In 2.8:

    x.map(kv =&gt; (kv._1,kv._2.toSet)).toMap

In 2.7:

    collection.immutable.Map(
      x.map(kv =&gt; (kv._1,collection.immutable.Set(kv._2.toList: _*))).toList: _*
    )



    scala&gt; val mutableMap = new HashMap[Int, String]
    mutableMap: scala.collection.mutable.HashMap[Int,String] = Map()
    
    scala&gt; mutableMap += 1 -&gt; &quot;a&quot;
    res5: mutableMap.type = Map((1,a))
    
    scala&gt; mutableMap
    res6: scala.collection.mutable.HashMap[Int,String] = Map((1,a))
    
    scala&gt; val immutableMap = mutableMap.toMap
    immutableMap: scala.collection.immutable.Map[Int,String] = Map((1,a))
    
    scala&gt; immutableMap += 2 -&gt; &quot;b&quot;
    &lt;console&gt;:11: error: reassignment to val
           immutableMap += 2 -&gt; &quot;b&quot;
                    ^

You can use `myMap.toMap` to convert an a mutable map into immutable in Scala 2.8 and later versions.

Looking at definition of `toMap` from documentation:

    def toMap[T, U](implicit ev: A &lt;:&lt; (T, U)): immutable.Map[T, U] = {
      val b = immutable.Map.newBuilder[T, U]
      for (x &lt;- self) b += x
      b.result
    }

You can just to the following

    val imm_map = MMMap.toMap

Can anyone suggest Go container for simple and fast FIF/queue, Go has 3 different containers: `heap`, `list` and `vector`. Which one is more suitable to implement a queue?

Is there a queue implementation?

I have a huge .bib file generated automatically from Papers for Mac and all the capitalization in the .bib is already the way I want it, but it doesn&#39;t have {} brackets on word like RNA.

Is there a way to force BibTeX to keep the capitalization rather than change some words to lowercase?

Preserving all capitalization in BibTeX

    private[this]object MMMap extends  HashMap[A, Set[B]] with MultiMap[A, B]
How convert it to immutable?

    


Converting mutable to immutable map

<pre><code class="hljs language-typescript">private[this]object MMMap extends HashMap[A, Set[B]] with MultiMap[A, B]
</code></pre>
How convert it to immutable?

In Scala, I can make a caseclass, `case class Foo(x:Int)`, and then put it in a list like so:

    List(Foo(42))

Now, nothing strange here. The following is strange to me. The operator `::` is a function on a list, right? With any function with one argument in Scala, I can call it with infix notation.
An example is `1 + 2` is a function `(+)` on the object `Int`. The class `Foo` I just defined does not have the `::` operator, so how is the following possible?

    Foo(40) :: List(Foo(2))

In Scala 2.8 RC1, I get the following output from the interactive prompt:

    scala&gt; case class Foo(x:Int)
    defined class Foo
    
    scala&gt; Foo(40) :: List(Foo(2))
    res2: List[Foo] = List(Foo(40), Foo(2))

I can go on and use it, but what is the explanation?


Scala&#39;s &#39;::&#39; operator, how does it work?

I find myself writing code like this when I want to repeat some execution n times:

    for (i &lt;- 1 to n) { doSomething() }

I&#39;m looking for a shorter syntax like this:

    n.times(doSomething())

Does something like this exist in Scala already?

**EDIT**

I thought about using Range&#39;s foreach() method, but then the block needs to take a parameter which it never uses.

    (1 to n).foreach(ignored =&gt; doSomething())


Is there a brief syntax for executing a block n times in Scala?

I have some big (more than 3 fields) objects that can and should be immutable. Every time I run into that case I tend to create constructor abominations with long parameter lists. 

It doesn&#39;t feel right, it is hard to use, and readability suffers.

It is even worse if the fields are some sort of collection type like lists. A simple `addSibling(S s)` would ease the object creation so much but renders the object mutable.

What do you guys use in such cases? 

I&#39;m on Scala and Java, but I think the problem is language agnostic as long as the language is object oriented.

Solutions I can think of:

1. &quot;Constructor abominations with long parameter lists&quot;
2. The Builder Pattern

Building big, immutable objects without using constructors having long parameter lists

[Language FAQ][1] says 

    import scala.collection.mutable.{_, Map =&gt; _, Set =&gt; _}

should import all classes from package `scala.collection.mutable`, except `Map` and `Set`. But it gives me this error: 

    error: &#39;}&#39; expected but &#39;,&#39; found.
           import scala.collection.mutable.{_, Map =&gt; _, Set =&gt; _}

Is there still a way to do this?

  [1]: http://scala.sygneca.com/faqs/language#how-do-i-import


How do I exclude/rename some classes from import in Scala?

[Hoogle][1] allows you to search many standard Haskell libraries by either function name, or by approximate type signature. I find it very useful. Is there anything like Hoogle for Scala? Search in [ScalaDoc 2][2] only finds types and packages by name.


  [1]: http://www.haskell.org/hoogle/
  [2]: http://www.scala-lang.org/archives/rc-api/index.html

Scala Hoogle equivalent?

I&#39;ve recent been reading about immutable strings https://stackoverflow.com/questions/93091 and https://stackoverflow.com/questions/2365272 as well some stuff about why [D][1] chose immutable strings.  There seem to be many advantages.

* trivially thread safe
* more secure
* more memory efficient in most use cases.
* cheap substrings (tokenizing and slicing)

Not to mention most new languages have immutable strings, D2.0, Java, C#, Python, etc.

Would C++ benefit from immutable strings?

Is it possible to implement an immutable string class in c++ (or c++0x) that would have all of these advantages?

---
update:

There are two attempts at immutable strings [const_string][2] and [fix_str][3].  Neither have been updated in half a decade.  Are they even used?  Why didn&#39;t const_string ever make it into boost?

  [1]: http://www.digitalmars.com/d/2.0/index.html
  [2]: http://conststring.sourceforge.net/
  [3]: http://www.codeproject.com/KB/string/fix_str.aspx

immutable strings vs std::string

How can one make a Java class immutable, what is the need of immutability and is there any advantage to using this?

Immutable class?

If a string is immutable, does that mean that....
(let&#39;s assume JavaScript)

    var str = &#39;foo&#39;;
    
    alert(str.substr(1)); // oo
    
    alert(str); // foo

Does it mean, when calling methods on a string, it will return the modified string, but it won&#39;t change the initial string?

If the string was mutable, does that mean the 2nd `alert()` would return `oo` as well?




What does immutable mean?

I have implemented a few Java applications now, only desktop applications so far. I prefer to use immutable objects for passing the data around in the application instead of using objects with mutators (setters *and getters*), also called JavaBeans.

But in the Java world, it seems to be much more common to use JavaBeans, and I can&#39;t understand why I should use them instead. Personally the code looks better if it only deals with immutable objects instead of mutate the state all the time. 

Immutable objects are also recommended in **Item 15: Minimize mutability**, *Effective Java 2ed*.

If I have an object `Person` implemented as a **JavaBean** it would look like:

    public class Person {
        private String name;
        private Place birthPlace;
    
        public Person() {}
    
        public setName(String name) {
            this.name = name;
        }
    
        public setBirthPlace(Place birthPlace) {
            this.birthPlace = birthPlace;
        }
    
        public String getName() {
            return name;
        }
    
        public Place getBirthPlace() {
            return birthPlace;
        }
    }

And the same `Person` implemented as an **immutable** object:

    public class Person {
        private final String name;
        private final Place birthPlace;
    
        public Person(String name, Place birthPlace) {
            this.name = name;
            this.birthPlace = birthPlace;
        }

        public String getName() {
            return name;
        }
     
        public Place getBirthPlace() {
            return birthPlace;
        }
    }

Or closer to an `struct` in C:

    public class Person {
        public final String name;
        public final Place birthPlace;
    
        public Person(String name, Place birthPlace) {
            this.name = name;
            this.birthPlace = birthPlace;
        }
    }

I could also have getters in the immutable object to hide the implementation details. But since I only use it as a `struct` I prefer to skip the &quot;getters&quot;, and keep it simple.

Simply, I don&#39;t understand why it&#39;s better to use JavaBeans, or if I can and should keep going with my immutable POJOs?

Many of the Java libraries seem to have better support for JavaBeans, but maybe more support for immutable POJOs gets more popular over time?


Why shouldn&#39;t I use immutable POJOs instead of JavaBeans?

First, I acknowledge the possibility that this question could be a duplicate; just let me know.

I&#39;m curious what the general &quot;best practice&quot; is for those situations when mutability is desired. F# seems to offer two facilities for this: the `let mutable` binding, which seems to work like variables in &quot;most&quot; languages, and the reference cell (created with the `ref` function) that requires explicit dereferencing to use.

There are a couple of cases where one is &quot;forced&quot; into one or the other: .NET interop tends to use mutable with `&lt;-`, and in workflow computations one must use `ref` with `:=`. So those cases are pretty clear-cut, but I&#39;m curious what to do when creating my own mutable variables outside of those scenarios. What advantage does one style have over the other? (Perhaps further insight into the implementation would help.)

Thanks!

F#: let mutable vs. ref

What is the syntax for adding an element to a scala.collection.mutable.Map ?

Here are some failed attempts:

    val map = scala.collection.mutable.Map
    
    map(&quot;mykey&quot;) = &quot;myval&quot;
    
    map += &quot;mykey&quot; -&gt; &quot;myval&quot;
    
    map.put(&quot;mykey&quot;,&quot;myval&quot;)

What is the syntax for adding an element to a scala.collection.mutable.Map?

Not sure if this is a style question, or something that has a hard rule...

If I want to keep the public method interface as const as possible, but make the object thread safe, should I use mutable mutexes? In general, is this good style, or should a non-const method interface be preferred? Please justify your view.


Should mutexes be mutable?

I am in a situation where I want to use mutable versions of things like Integer. Do I have to use these classes (below) or does Java have something built in?

http://www.java2s.com/Code/Java/Data-Type/Amutableintwrapper.htm 

Does Java have mutable types for Integer, Float, Double, Long?

I know this is probably very stupid, but a lot of places claim that the Integer class in Java is immutable, yet the following code:

    Integer a=3;
    Integer b=3;
    a+=b;
    System.out.println(a);
Executes without any trouble giving the (expected) result 6. So effectively the value of a has changed. Doesn&#39;t that mean Integer is mutable?
Secondary question and a little offtopic: &quot;Immutable classes do not need copy constructors&quot;. Anyone care to explain why?


Is Integer Immutable

In Scala, for many (all?) types of collections you can create views.

What exactly is a view and for which purposes are views useful?

What are views for collections and when would you want to use them?

I&#39;m starting to explore Scala, and one of the things I&#39;m intrigued by is the `Option` type and the promise of being able to eliminate `null` related errors.

However I haven&#39;t been able to work out how to transform a list (or other collection) of, say, `Option[String]`, to a collection of `String` (obviously filtering out any values that are `None`).

In other words, how do I get from this:

    List[Option[Int]] = List(Some(1))

... to this:

    List[Int] = List(1)

I&#39;m using Scala 2.8 if that has any impact on the answer.

How to transform Scala collection of Option[X] to collection of X

What are the differences among Streams, Views (SeqView), and Iterators in scala? This is my understanding:

* They are all lazy lists.
* Streams cache the values.
* Iterators can only be used once? You can&#39;t go back to the beginning and evaluate the value again?
* View&#39;s values are not cached but you can evaluate them again and again?

So if I want to save heap space, should I use iterators (if I won&#39;t traverse the list again) or views? Thanks. 

Stream vs Views vs Iterators

There&#39;s something I don&#39;t understand about Scala&#39;s [`collection.mutable.Seq`](http://www.scala-lang.org/api/current/index.html#scala.collection.mutable.Seq). It describes the interface for all mutable sequences, yet I don&#39;t see methods to append or prepend elements without creating a new sequence. Am I missing something obvious here?

There are `:+` and `+:` for append and prepend, respectively, but they create new collections — in order to be consistent with the behavior of immutable sequences, I assume. This is fine, but why is there no method like `+=` and `+=:`, like `ArrayBuffer` and `ListBuffer` define, for in-place append and prepend? Does it mean that I cannot refer to a mutable seq that&#39;s typed as `collection.mutable.Seq` if I want to do in-place append?

Again, I must have missed something obvious, but cannot find what…

How to append or prepend on a Scala mutable.Seq

It seems that `Vector` was late to the Scala collections party, and all the influential blog posts had already left.

In Java `ArrayList` is the default collection - I might use `LinkedList` but only when I&#39;ve thought through an algorithm and care enough to optimise. In Scala should I be using `Vector` as my default `Seq`, or trying to work out when `List` is actually more appropriate?

Content Type	Original Author	Original Content on Stackoverflow
Question	Jeriho	View Question on Stackoverflow
Solution 1 - Scala	Rex Kerr	View Answer on Stackoverflow
Solution 2 - Scala	michael.kebe	View Answer on Stackoverflow
Solution 3 - Scala	Fahad Siddiqui	View Answer on Stackoverflow
Solution 4 - Scala	Harish Gajapathy	View Answer on Stackoverflow

Converting mutable to immutable map

Scala Problem Overview

Scala Solutions

Solution 1 - Scala

Solution 2 - Scala

Solution 3 - Scala

Solution 4 - Scala

Preserving all capitalization in BibTeX

Is there a queue implementation?

Attributions