immutability

I would like to construct my domain model using immutable objects only. But I also want to use traits with val fields and move some functionality to traits. Please look at the following example: trait Versionable { val version = 0 def incrementVersion = copy(version=version+1) } Unfortunatelly such code doesn't work - copy method is unknown for trait Versionable. I think that it would be nice to have copy method generated for every trait and class. Such method should create shallow copy of object and return it using the same type as for original object with given field modified accoring to

Much is written about the advantages of immutable state, but are there common cases in Scala where it makes sense to prefer mutable classes? (This is a Scala newbie question from someone with a background in "classic" OOP design using mutable classes.) For something trivial like a 3-dimensional Point class, I get the advantages of immutability. But what about something like a Motor class, which exposes a variety of control variables and/or sensor readings? Would a seasoned Scala developer typically write such a class to be immutable? In that case, would 'speed' be represented internally as a

In Java strings are immutable. If we have a string and make changes to it, we get new string referenced by the same variable: String str = "abc"; str += "def"; // now str refers to another piece in the heap containing "abcdef" // while "abc" is still somewhere in the heap until taken by GC It's been said that int and double are immutable in C#. Does it mean that when we have int and later change it, we would get new int "pointed" by the same variable? Same thing but with stack. int i = 1; i += 1; // same thing: in the stack there is value 2 to which variable // i is attached, and somewhere in

I am playing with the Jackson examples and am having some trouble getting deserialization to work with immutable classes and interfaces. Below is my code: package com.art.starter.jackson_starter; import java.io.IOException; import java.io.StringReader; import java.io.StringWriter; import org.codehaus.jackson.JsonGenerationException; import org.codehaus.jackson.map.JsonMappingException; import org.codehaus.jackson.map.ObjectMapper; /** * Hello world! * */ public class App { public static void main( String[] args ) throws JsonGenerationException, JsonMappingException, IOException { System.out

In our application, we need to have fields that are assignable only once. At first we thought of encapsulating the fields and making the setters private. However, some questions arouse: Without a public setter, is Hibernate still able to map the field from the database? Can I strip out the setter and make the field mutable only in the entity constructor? Finally, is there any standard JPA way to make a field immutable? Thanks in advance. Ad. 1: I believe JPA uses plain private fields for both read and write if annotations are placed on fields and not on getters. Recently I discovered that