An immutable type is a type of which its properties can only be set at initialization. Once an object is created, nothing can be changed anymore. An immutable property is simply a read-only property. In the following example, ImmutableType is an immutable type with one property Test. Test is a read-only property. It can only … Read more
If this class is immutable, won’t it take a huge amount of memory? Typically your memory requirements for that single object might double, because you might have an “old copy” and a “new copy” live at once. So you can view this phenomenon, over the lifetime of the program, as having one more large object … Read more
In Scala 2.8: Welcome to Scala version 2.8.0.r20327-b20091230020149 (Java HotSpot(TM) Client VM, Java 1.6. Type in expressions to have them evaluated. Type :help for more information. scala> val seq: Seq[(String,Object)] = (“a”,”A”)::(“b”,”B”)::Nil seq: Seq[(String, java.lang.Object)] = List((a,A), (b,B)) scala> val map = Map(seq: _*) map: scala.collection.immutable.Map[String,java.lang.Object] = Map(a -> A, b -> B) scala> val … Read more
how do I determine if the object referenced by boo is modified inside the body of the function (maybe using annotations)? The only way is to read the code unfortunately. If there is no way to know, is there some widely used convention or some best practices to avoid confusion and bugs? The common convention … Read more
TL;DR MappingProxyType is a read only proxy for mapping (e.g. dict) objects. frozendict is an immutable dict Answer The proxy pattern is (quoting wikipedia): A proxy, in its most general form, is a class functioning as an interface to something else. The MappingProxyType is just a simple proxy (i.e. interface) to access the real object … Read more
It’s impossible to have immutability of a single field. That was an option in an ancient version of Rust (think before 0.8), but it was dropped because the rules confused a LOT of people. How was it confusing, you might ask? Think about it like this: if a field is declared mutable and struct is … Read more
That would be const. Note that this keyword means a couple of different things in different contexts.
Assuming this is your “immutable” object : public class Immutable { public Immutable(string foo, int bar) { this.Foo = foo; this.Bar = bar; } public string Foo { get; private set; } public int Bar { get; private set; } } You can create a dummy class to represent that immutable object during serialization/deserialization : … Read more
I believe the confusion is because you’re conflating names with storage. fn main() { let x = 5; // x_0 println!(“The value of x is {}”, x); let x = 6; // x_1 println!(“The value of x is {}”, x); } In this example, there is one name (x), and two storage locations (x_0 and … Read more
This seems to work… function getList(): ReadonlyArray<number> { return [1, 2, 3]; } const list = getList(); list[0] = 3; // Index signature in type ‘ReadonlyArray<number>’ only permits reading. Try it in the Playground ReadonlyArray<T> is implemented like this: interface ReadonlyArray<T> { readonly [n: number]: T; // Rest of the interface removed for brevity. }