immutability

A glance at the source code for string.GetHashCode using Reflector reveals the following (for mscorlib.dll version 4.0): public override unsafe int GetHashCode() { fixed (char* str = ((char*) this)) { char* chPtr = str; int num = 0x15051505; int num2 = num; int* numPtr = (int*) chPtr; for (int i = this.Length; i > 0; i -= 4) { num = (((num << 5) + num) + (num >> 0x1b)) ^ numPtr[0]; if (i <= 2) { break; } num2 = (((num2 << 5) + num2) + (num2 >> 0x1b)) ^ numPtr[1]; numPtr += 2; } return (num + (num2 * 0x5d588b65)); } } Now, I realize that the implementation of GetHashCode is not specified and is

According to MDN Object.freeze() documentation : The Object.freeze() method freezes an object: that is, prevents new properties from being added to it; prevents existing properties from being removed; and prevents existing properties, or their enumerability, configurability, or writability, from being changed. In essence the object is made effectively immutable. The method returns the object being frozen. I was expecting that calling freeze on a date would prevent changes to that date, but it does not appear to be working. Here's what I am doing (running Node.js v5.3.0): let d = new Date()

Why should objects in Redux be immutable? I know that some frameworks such as Angular2 will use onPush and can take advantage of immutability to compare states of views for faster rendering, but I am wondering if there are other reasons as Redux is framework agnostic and yet it mentions within its own docs to use immutability (regardless of the framework). Appreciate any feedback. Ashley Coolman Redux is a small library that represents state as (immutable) objects. And new states by passing the current state through pure functions to create an entirely new object/application states. If your

JavaDoc of ImmutableSet says: Unlike Collections.unmodifiableSet , which is a view of a separate collection that can still change, an instance of this class contains its own private data and will never change. This class is convenient for public static final sets ("constant sets") and also lets you easily make a "defensive copy" of a set provided to your class by a caller. But the ImmutableSet still stores reference of elements, I couldn't figure out the difference to Collections.unmodifiableSet() . Sample: StringBuffer s=new StringBuffer("a"); ImmutableSet<StringBuffer> set= ImmutableSet.of(s

Let's say I store bank accounts information in an immutable Map : val m = Map("Mark" -> 100, "Jonathan" -> 350, "Bob" -> 65) and I want to withdraw, say, $50 from Mark's account. I can do it as follows: val m2 = m + ("Mark" -> (m("Mark") - 50)) But this code seems ugly to me. Is there better way to write this? There's no adjust in the Map API, unfortunately. I've sometimes used a function like the following (modeled on Haskell's Data.Map.adjust , with a different order of arguments): def adjust[A, B](m: Map[A, B], k: A)(f: B => B) = m.updated(k, f(m(k))) Now adjust(m, "Mark")(_ - 50) does what

I need help getting my head around the difference between my current OOP notion of state, and the way it would be done in a functional language like Haskell or Clojure. To use a hackneyed example, let's say we're dealing with simplified bank account objects/structs/whatever. In an OOP language, I'd have some class holding a reference to a BankAccount, which would have instance variables for things like interest rate, and methods like setInterestRate() which change the object's state and generally return nothing. In say Clojure, I'd have a bank-account struct (a glorified hashmap), and special