I needed to create a list of lists in Python, so I typed the following:  

    my_list = [[1] * 4] * 3

The list looked like this:  

    [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]  

Then I changed one of the innermost values:  

    my_list[0][0] = 5

Now my list looks like this:  

    [[5, 1, 1, 1], [5, 1, 1, 1], [5, 1, 1, 1]]  

which is not what I wanted or expected. Can someone please explain what&#39;s going on, and how to get around it?

List of lists changes reflected across sublists unexpectedly

A while ago I came across some code that marked a member variable of a class with the `mutable` keyword.  As far as I can see it simply allows you to modify a variable in a `const` method:

    class Foo  
    {  
    private:  
        mutable bool done_;  
    public:  
        void doSomething() const { ...; done_ = true; }  
    };

  
Is this the only use of this keyword or is there more to it than meets the eye?  I have since used this technique in a class, marking a `boost::mutex` as mutable allowing `const` functions to lock it for thread-safety reasons, but, to be honest, it feels like a bit of a hack.

Does the &#39;mutable&#39; keyword have any purpose other than allowing the variable to be modified by a const function?

Following the discussions here on SO I already read several times the remark that mutable structs are “evil” (like in the answer to this [question][1]).

What&#39;s the actual problem with mutability and structs in C#? 


  [1]: https://stackoverflow.com/questions/292676/is-there-a-workaround-for-overloading-the-assignment-operator-in-c

Why are mutable structs “evil”?

I&#39;m confused on what an immutable type is. I know the `float` object is considered to be immutable, with this type of example from my book:

    class RoundFloat(float):
        def __new__(cls, val):
            return float.__new__(cls, round(val, 2))

Is this considered to be immutable because of the class structure / hierarchy?, meaning `float` is at the top of the class and is its own method call. Similar to this type of example (even though my book says `dict` is mutable):

    class SortedKeyDict(dict):
        def __new__(cls, val):
            return dict.__new__(cls, val.clear())

Whereas something mutable has methods inside the class, with this type of example:
    
    class SortedKeyDict_a(dict):
        def example(self):
            return self.keys()

----------

Also, for the last `class(SortedKeyDict_a)`, if I pass this type of set to it:

    d = ((&#39;zheng-cai&#39;, 67), (&#39;hui-jun&#39;, 68),(&#39;xin-yi&#39;, 2))

without calling the `example` method, it returns a dictionary. The `SortedKeyDict` with `__new__` flags it as an error. I tried passing integers to the `RoundFloat` class with `__new__` and it flagged no errors.

Immutable vs Mutable types

Why is it that they decided to make `String` immutable in Java and .NET (and some other languages)? Why didn&#39;t they make it mutable?


Why can&#39;t strings be mutable in Java and .NET?

I&#39;m trying to get my head around mutable vs immutable objects. Using mutable objects gets a lot of bad press (e.g. returning an array of strings from a method) but I&#39;m having trouble understanding what the negative impacts are of this. What are the best practices around using mutable objects? Should you avoid them whenever possible?

Mutable vs immutable objects

Can anyone amend [namedtuple][1] or provide an alternative class so that it works for mutable objects?

Primarily for readability, I would like something similar to namedtuple that does this:

    from Camelot import namedgroup
    
    Point = namedgroup(&#39;Point&#39;, [&#39;x&#39;, &#39;y&#39;])
    p = Point(0, 0)
    p.x = 10
    
    &gt;&gt;&gt; p
    Point(x=10, y=0)

    &gt;&gt;&gt; p.x *= 10
    Point(x=100, y=0)

It must be possible to pickle the resulting object.  And per the characteristics of named tuple, the ordering of the output when represented must match the order of the parameter list when constructing the object.


  [1]: http://code.activestate.com/recipes/500261/

Existence of mutable named tuple in Python?

It is a common mistake in Python to set a mutable object as the default value of an argument in a function. Here&#39;s an example taken from [this excellent write-up by David Goodger][1]:

    &gt;&gt;&gt; def bad_append(new_item, a_list=[]):
            a_list.append(new_item)
            return a_list
    &gt;&gt;&gt; print bad_append(&#39;one&#39;)
    [&#39;one&#39;]
    &gt;&gt;&gt; print bad_append(&#39;two&#39;)
    [&#39;one&#39;, &#39;two&#39;]

The explanation why this happens is [here][2].

And now for my question: **Is there a good use-case for this syntax?** 

I mean, if everybody who encounters it makes the same mistake, debugs it, understands the issue and from thereon tries to avoid it, what use is there for such syntax?

  [1]: http://www.omahapython.org/IdiomaticPython.html
  [2]: http://www.omahapython.org/IdiomaticPython.html#default-parameter-values

Good uses for mutable function argument default values?

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

Here are two function signatures I saw in the Rust documentation:

    fn modify_foo(mut foo: Box&lt;i32&gt;) { *foo += 1; *foo }
    fn modify_foo(foo: &amp;mut i32) { *foo += 1; *foo }

Why the different placement of `mut`?

It seems that the first function could also be declared as

    fn modify_foo(foo: mut Box&lt;i32&gt;) { /* ... */ }

What&#39;s the difference between placing &quot;mut&quot; before a variable name and after the &quot;:&quot;?

I have an array I&#39;d like to turn into a `List`, in order to modify the contents of the array.

Stack Overflow has plenty of questions/answers that address `Arrays.asList()` and how it only provides a List view of the underlying array, and how attempting to manipulate the resulting List will generally throw an `UnsupportedOperationException` as methods used to manipulate the list (e.g. `add()`, `remove()`, etc.) are not implemented by the List implementation provided by `Arrays.asList()`.

But I can&#39;t find an example of how to turn an array into a mutable List.  I suppose I can loop through the array and `put()` each value into a new List, but I&#39;m wondering if there&#39;s an interface that exists to do this for me.

Create mutable List from array?

I want to do this:

    struct Point {
        x: i32,
        y: i32,
    }
    
    impl Point {
        fn up(&amp;self) {
            self.y += 1;
        }
    }
    
    fn main() {
        let p = Point { x: 0, y: 0 };
        p.up();
    }


But this code throws a compiler error:

&lt;!-- language: none --&gt;

    error[E0594]: cannot assign to field `self.y` of immutable binding
     --&gt; src/main.rs:8:9
      |
    7 |     fn up(&amp;self) {
      |           ----- use `&amp;mut self` here to make mutable
    8 |         self.y += 1;
      |         ^^^^^^^^^^^ cannot mutably borrow field of immutable binding



How I can mutate a struct&#39;s field from a method?

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 have a question about the difference between volatile and mutable. I noticed that both of the two means that it could be changed. What else? Are they the same thing? What&#39;s the difference? Where are they applicable? Why the two ideas are proposed? How to use them in different way?

Thanks a lot. 

volatile vs. mutable in C++

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

I was referring to Apple&#39;s Swift programming guide for understanding creation of Mutable/ immutable objects(Array, Dictionary, Sets, Data) in Swift language. But I could&#39;t understand how to create a immutable collections in Swift. 

I would like to see the equivalents in Swift for the following in Objective-C

**Immutable Array**

    NSArray *imArray = [[NSArray alloc]initWithObjects:@&quot;First&quot;,@&quot;Second&quot;,@&quot;Third&quot;,nil];

**Mutable Array**

    NSMutableArray *mArray = [[NSMutableArray alloc]initWithObjects:@&quot;First&quot;,@&quot;Second&quot;,@&quot;Third&quot;,nil];
    [mArray addObject:@&quot;Fourth&quot;];

**Immutable Dictionary**

    NSDictionary *imDictionary = [[NSDictionary alloc] initWithObjectsAndKeys:@&quot;Value1&quot;, @&quot;Key1&quot;, @&quot;Value2&quot;, @&quot;Key2&quot;, nil];

**Mutable Dictionary**

    NSMutableDictionary *mDictionary = [[NSMutableDictionary alloc]initWithObjectsAndKeys:@&quot;Value1&quot;, @&quot;Key1&quot;, @&quot;Value2&quot;, @&quot;Key2&quot;, nil];
    [mDictionary setObject:@&quot;Value3&quot; forKey:@&quot;Key3&quot;];


Immutable/Mutable Collections in Swift

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?

I am using Typeahead by twitter. I am running into this warning from Intellij. This is causing the &quot;window.location.href&quot; for each link to be the last item in my list of items.

How can I fix my code?

Below is my code:

    AutoSuggest.prototype.config = function () {
        var me = this;
        var comp, options;
        var gotoUrl = &quot;/{0}/{1}&quot;;
        var imgurl = &#39;&lt;img src=&quot;/icon/{0}.gif&quot;/&gt;&#39;;
        var target;
    
        for (var i = 0; i &lt; me.targets.length; i++) {
            target = me.targets[i];
            if ($(&quot;#&quot; + target.inputId).length != 0) {
                options = {
                    source: function (query, process) { // where to get the data
                        process(me.results);
                    },
    
                    // set max results to display
                    items: 10,
    
                    matcher: function (item) { // how to make sure the result select is correct/matching
                        // we check the query against the ticker then the company name
                        comp = me.map[item];
                        var symbol = comp.s.toLowerCase();
                        return (this.query.trim().toLowerCase() == symbol.substring(0, 1) ||
                            comp.c.toLowerCase().indexOf(this.query.trim().toLowerCase()) != -1);
                    },
    
                    highlighter: function (item) { // how to show the data
                        comp = me.map[item];
                        if (typeof comp === &#39;undefined&#39;) {
                            return &quot;&lt;span&gt;No Match Found.&lt;/span&gt;&quot;;
                        }
    
                        if (comp.t == 0) {
                            imgurl = comp.v;
                        } else if (comp.t == -1) {
                            imgurl = me.format(imgurl, &quot;empty&quot;);
                        } else {
                            imgurl = me.format(imgurl, comp.t);
                        }
    
                        return &quot;\n&lt;span id=&#39;compVenue&#39;&gt;&quot; + imgurl + &quot;&lt;/span&gt;&quot; +
                            &quot;\n&lt;span id=&#39;compSymbol&#39;&gt;&lt;b&gt;&quot; + comp.s + &quot;&lt;/b&gt;&lt;/span&gt;&quot; +
                            &quot;\n&lt;span id=&#39;compName&#39;&gt;&quot; + comp.c + &quot;&lt;/span&gt;&quot;;
                    },
    
                    sorter: function (items) { // sort our results
                        if (items.length == 0) {
                            items.push(Object());
                        }
    
                        return items;
                    },
    // the problem starts here when i start using target inside the functions
                    updater: function (item) { // what to do when item is selected
                        comp = me.map[item];
                        if (typeof comp === &#39;undefined&#39;) {
                            return this.query;
                        }
    
                        window.location.href = me.format(gotoUrl, comp.s, target.destination);
    
                        return item;
                    }
                };
    
                $(&quot;#&quot; + target.inputId).typeahead(options);
    
                // lastly, set up the functions for the buttons
                $(&quot;#&quot; + target.buttonId).click(function () {
                    window.location.href = me.format(gotoUrl, $(&quot;#&quot; + target.inputId).val(), target.destination);
                });
            }
        }
    };

With @cdhowie&#39;s help, some more code: 
i will update the updater and also the href for the click()

    updater: (function (inner_target) { // what to do when item is selected
        return function (item) {
            comp = me.map[item];
            if (typeof comp === &#39;undefined&#39;) {
                return this.query;
            }
    
            window.location.href = me.format(gotoUrl, comp.s, inner_target.destination);
            return item;
    }}(target))};


Mutable variable is accessible from closure. How can I fix this?

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


Converting mutable to immutable 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?

Is it bad practice to use mutable objects as Hashmap keys?  What happens when you try to retrieve a value from a Hashmap using a key that has been modified enough to change its hashcode?

For example, given

    class Key
    {
        int a; //mutable field
        int b; //mutable field
    
        public int hashcode()
            return foo(a, b);
        // setters setA and setB omitted for brevity
    }

with code

    HashMap&lt;Key, Value&gt; map = new HashMap&lt;Key, Value&gt;();

    Key key1 = new Key(0, 0);
    map.put(key1, value1); // value1 is an instance of Value

    key1.setA(5);
    key1.setB(10);

What happens if we now call `map.get(key1)`?  Is this safe or advisable?  Or is the behavior dependent on the language?

Are mutable hashmap keys a dangerous practice?

I have a list:

&lt;!-- language-all: kotlin --&gt;

    val someList = listOf(1, 20, 10, 55, 30, 22, 11, 0, 99)

And I want to iterate it while modifying some of the values.  I know I can do it with `map` but that makes a copy of the list.  

    val copyOfList = someList.map { if (it &lt;= 20) it + 20 else it }

How do I do this without a copy?

**Note:** *this question is intentionally written and answered by the author ([Self-Answered Questions](https://blog.stackoverflow.com/2011/07/its-ok-to-ask-and-answer-your-own-questions/)), so that the idiomatic answers to commonly asked Kotlin topics are present in SO.  Also to clarify some really old answers written for alphas of Kotlin that are not accurate for current-day Kotlin.*

In Kotlin, how do you modify the contents of a list while iterating

I am writing an Array-derived class in JavaScript and need to know which functions to overload so that I can be aware of changes made to the array.

I know `Array.push()` and `Array.splice()` are mutating. Is there a definitive list of any others?

Which JavaScript Array functions are mutating?

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

As per my knowledge,

a mutable string can be changed, and
an immutable string cannot be changed.

Here I want to change the value of String like this,

    String str=&quot;Good&quot;;
    str=str+&quot; Morning&quot;;

and other way is,

    StringBuffer str= new StringBuffer(&quot;Good&quot;);
    str.append(&quot; Morning&quot;);

In both the cases I am trying to alter the value of `str`. Can anyone tell me, what is difference in both case and give me clear picture of mutable and immutable objects.

All Mutable Solutions on Gang of Coders

Total of 25 Mutable Solutions