immutability

I would like to make an object's structure immutable, preventing its properties from being subsequently replaced. The properties need to be readable, however. Is this possible? I'm sure there are no language features (along the lines of final in Java and readonly in C#) to support this but wondered whether there might be another mechanism for achieving the same result? I'm looking for something along these lines: var o = { a: "a", f: function () { return "b"; } }; var p = o.a; // OK o.a = "b"; // Error var q = o.f(); // OK o.f = function () { // Error return "c"; }; ECMAScript 5 will have seal

StringBuiler is a mutable object, F# encourages employing immutability as much as possible. So one should use transformation rather than mutation. Does this apply to StringBuilder when it comes to building a string in F#? Is there an F# immutable alternative to it? If so, is this alternative as efficient? A snippet I think that using StringBuilder in F# is perfectly fine - the fact that sb.Append returns the current instance of StringBuilder means that it can be easily used with the fold function. Even though this is still imperative (the object is mutated), it fits reasonably well with the

I would like to write something like this: var d = new ImmutableDictionary<string, int> { { "a", 1 }, { "b", 2 } }; (using ImmutableDictionary from System.Collections.Immutable ). It seems like a straightforward usage as I am declaring all the values upfront -- no mutation there. But this gives me error: The type ' System.Collections.Immutable.ImmutableDictionary<TKey,TValue> ' has no constructors defined How I am supposed to create a new immutable dictionary with static content? Dirk You can't create immutable collection with a collection initializer because the compiler translates them into

What is the difference between the const and immutable type qualifiers in D? Something that is const cannot be mutated via that reference but could be mutated by a mutable reference to the same data. Something that is immutable can't be mutated by any reference to that data. So, if you have const C c = foo(); then you know that you cannot mutate the object referred to by c through c , but other references to the object referred to by c may exist in your code, and if they're mutable, they could mutate it and therefore change what c sees. But if you have immutable C c = foo(); then you know that

What is meant by immutable type and immutable property in C# ? can you give simple example? fretje 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 be set at construction. class ImmutableType { private readonly string _test; public string Test { get { return _test; } } public ImmutableType(string test) { _test = test; }