immutability

I've discovered a strange behavior for mutable sets which I cannot understand: I have a object which I want to add to a set. The equals method for the class is overridden. When I add two different objects to the set, which produces the same output for equals method, I get a different behavior between mutable and immutable sets for the contains method. Here is the code snippet: class Test(text:String){ override def equals(obj:Any) = obj match { case t: Test => if (t.text == this.text) true else false case _ => false } override def toString = text } val mutableSet:scala.collection.mutable.Set

In the book Java Concurrency In Practice it explains the advantages of "effectively immutable" objects versus mutable objects concurrency-wise. But it does not explain what advantage "effectively immutables" objects would offer over really immutable objects. And I don't get it: can't you always build a really immutable object at the moment you'd decide to publish safely an "effectively immutable" object? (instead of doing your "safe publication" you'd build a really immutable object and that's it) When I'm designing classes I fail to see cases where I couldn't always build a truly immutable

What's the difference between enum i = 2; enum s = "Hello"; and immutable i = 2; immutable s = "Hello"; in D 2.0? stephan An enum is a user-defined type, not a variable. enum e = 2; is a short-hand for something like this enum : int { e = 2 } (i.e. an anonymous enum with one member e ), see the documentation . By definition, all members of an anonymous enum are placed into the current scope. So, e is a type member placed into the current scope, where it behaves like a literal . immutable i = 2; on the other hand actually creates a variable i of type int. This difference has a couple of

Hey, i try to trim each string item of an list in groovy list.each() { it = it.trim(); } But this only works within the closure, in the list the strings are still " foo", "bar " and " groovy ". How can i achieve that? list = list.collect { it.trim() } You could also use the spread operator: def list = [" foo", "bar ", " groovy "] list = list*.trim() assert "foo" == list[0] assert "bar" == list[1] assert "groovy" == list[2] According to the Groovy Quick Start , using collect will collect the values returned from the closure. Here's a little example using the Groovy Shell: groovy:000> ["a ", " b

I'm looking for a way to freeze native ES6 Maps. Object.freeze and Object.seal don't seem to work: let myMap = new Map([["key1", "value1"]]); // Map { 'key1' => 'value1' } Object.freeze(myMap); Object.seal(myMap); myMap.set("key2", "value2"); // Map { 'key1' => 'value1', 'key2' => 'value2' } Is this intended behavior since freeze freezes properties of objects and maps are no objects or might this be a bug / not implemented yet? And yes I know, I should probably use Immutable.js , but is there any way to do this with native ES6 Maps? There is not, you could write a wrapper to do that. Object

I need to manipulate and modify deeply nested immutable collections (maps and lists), and I'd like to better understand the different approaches. These two libraries solve more or less the same problem, right? How are they different, what types of problem is one approach more suitable for over the other? Clojure's assoc-in Haskell's lens Clojure's assoc-in lets you specify a path through a nested data struture using integers and keywords and introduce a new value at that path. It has partners dissoc-in , get-in , and update-in which remove elements, get them without removal, or modify them

I always thought that the benefit of linked lists was that you could add or remove items (especially not from the end) without having to copy lots of elements thanks to the beauty of pointers. However, Scala's List is immutable (at least by default). What is the benefit of having an immutable linked list (because there are definite downsides, e.g. not O(1) element access.) Thanks! I think the main reason is that one of the most powerful uses of linked lists is head/tail splitting. There are lots of recursive algorithms that look like this one: def listlen[A](xs: List[A], already: Int = 0): Int