CODEWITHSUNDEEP
scala
Will I Am
Will I Am

Reputation: 2682

Idiomatic way of modifying an immutable collection

I'm interested in understanding the pattern of modifying an immutable collection in the most effective way.

Suppose for example I want to define the following class (an actual implementation may overload the operators, but this is just for illustration). Is this the best way (with respect to performance / safety)?

import scala.collection.immutable.HashMap
class Example[A,B] {
  var col = new HashMap[A, B]()
  def add(k: A, v: B): Unit = col =  col +  (k -> v)
  def remove(k: A): Unit = col = col - k  
}

would this approach be possible as well, in some way I'm missing?

class Example[A,B] extends HashMap[A,B] {
  def add(k: A, v: B): Unit = ???
  def remove(k: A): Unit = ???
}

Upvotes: 2

Views: 101

Answers (2)

turbo_laser
turbo_laser

Reputation: 261

The comments above are correct. The idea of immutable data structures exists and there are ways to do it, however, it seems that you may just want to stick with a mutable structure since you have a var anyway.

Check out chapter 17 of the free online pdf of Programming In Scala here where Odersky discusses the designing and building of an Immutable queue.

The gist of it is that you never actually modify the structure that you're trying to change, you just take it in, look at it, and then build a new one based on the old one and whatever it is you're trying to do.

It's the same idea behind the fact that with lists:

val list = List(1,2,3)
1 :: list
println(list)

Will print out List(1,2,3) as opposed to List(1,1,2,3)

While:

val list = List(1,2,3)
val list1 = 1 :: list
println(list1)

is what prints List(1,1,2,3)

Here's a nice slide deck that discusses some popular data structures and their functional counterparts. Functional Data Structures

Upvotes: 2

andyczerwonka
andyczerwonka

Reputation: 4260

It sounds like you're trying to make immutable data structures mutable. There are situations where you need to think about performance to be sure, but given that Scala has persistent data structures I'd focus on the use case and not the performance model.

val a = Map("key1" -> "some value")
val b = a + ("key2" -> "some other value")

Now b contains both entries.

If you actually need the mutable structures for your case, just use the mutable.Map.

Upvotes: 1

Related Questions