immutability

Could you please clarify that why final keyword is required before class when we are making it an immutable one. I mean, if we declare all of it's attributes as private and final, then also it is an immutable class, isn't it? Sorry if the question seems easy, but i am truly confused about it. Help me out. Editted: I know that a class declared final can't be subclassed.. But if each attribute is private and final then what difference does that make? Jon Skeet As stacker says, final makes sure the class isn't subclassed. That's important so that any code which is relying on its immutability can

How can I deal with this error without creating additional variable? func reduceToZero(x:Int) -> Int { while (x != 0) { x = x-1 // ERROR: cannot assign to 'let' value 'x' } return x } I don't want to create additional variable just to store the value of x. Is it even possible to do what I want? As stated in other answers, as of Swift 3 placing var before a variable has been deprecated. Though not stated in other answers is the ability to declare an inout parameter. Think: passing in a pointer. func reduceToZero(_ x: inout Int) { while (x != 0) { x = x-1 } } var a = 3 reduceToZero(&a) print(a)

I am making most of my basic types in my app, immutable. But should the collections be immutable too? To me, this seems like a huge overhead unless I am missing something. I am talking about collections to hold Point3 values, etc which can be added as it goes at different times. So if there are 1M values in a collection, and you needed to delete 1 of them, you would have to create the same collection all over again, right? Joel Coehoorn Eric Lippert has a series on Immutability in C#, and if you read it all the way through he implements a couple different immutable collections: Immutability in

I've been thinking for a while about how to go about implementing a deque (that is, a double-ended queue) as an immutable data structure. There seem to be different ways of doing this. AFAIK, immutable data structures are generally hierarchical , so that major parts of it can be reused after modifying operations such as the insertion or removal of an item. Eric Lippert has two articles on his blog about this topic, along with sample implementations in C#. Both of his implementations strike me as more elaborate than is actually necessary. Couldn't deques simply be implemented as binary trees,

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="Good"; str=str+" Morning"; and other way is, StringBuffer str= new StringBuffer("Good"); str.append(" Morning"); 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. TheLostMind Case 1: String str = "Good"; str = str + " Morning"; In the above code you create 3 String Objects. "Good" it goes into the String Pool . "

I've read a couple of articles on immutability but still don't follow the concept very well. I made a thread on here recently which mentioned immutability, but as this is a topic in itself, I am making a dedicated thread now. I mentioned in the past thread that I thought immutability is the process of making an object read only and giving it low visibility. Another member said it didn't really have anything to do with that. This page (part of a series ) uses an example of an immutable class/struct and it uses readonly and other concepts to lock it down. What exactly is the definition of state

While I understand why a var cannot override a val in subclass and vice versa, I am unable to understand why does Scala not allow a def in subclass to override a var in superclass class Car { var age = 32 } class SedanCar extends Car { override def age = 54 } As var is mutable why not allow a def to override it? Can anyone please help me in understanding this? dk14 That's related to the Liskov Substitution Principle : you can't assign weaker access privileges in subclass (even for Java) . Making var a def makes the setter def x_= (y: T ): Unit private (as @Staix said). So in case when Seadan