Is the Scala 2.8 collections library a case of “the longest suicide note in history”? [closed]

by

I hope it’s not a “suicide note”, but I can see your point. You hit on what is at the same time both a strength and a problem of Scala: its extensibility. This lets us implement most major functionality in libraries. In some other languages, sequences with something like map or collect would be built in, and nobody has to see all the hoops the compiler has to go through to make them work smoothly. In Scala, it’s all in a library, and therefore out in the open.

In fact the functionality of map that’s supported by its complicated type is pretty advanced. Consider this:

scala> import collection.immutable.BitSet
import collection.immutable.BitSet

scala> val bits = BitSet(1, 2, 3)
bits: scala.collection.immutable.BitSet = BitSet(1, 2, 3)

scala> val shifted = bits map { _ + 1 }
shifted: scala.collection.immutable.BitSet = BitSet(2, 3, 4)

scala> val displayed = bits map { _.toString + "!" }
displayed: scala.collection.immutable.Set[java.lang.String] = Set(1!, 2!, 3!)

See how you always get the best possible type? If you map Ints to Ints you get again a BitSet, but if you map Ints to Strings, you get a general Set. Both the static type and the runtime representation of map’s result depend on the result type of the function that’s passed to it. And this works even if the set is empty, so the function is never applied! As far as I know there is no other collection framework with an equivalent functionality. Yet from a user perspective this is how things are supposed to work.

The problem we have is that all the clever technology that makes this happen leaks into the type signatures which become large and scary. But maybe a user should not be shown by default the full type signature of map? How about if she looked up map in BitSet she got:

map(f: Int => Int): BitSet     (click here for more general type)

The docs would not lie in that case, because from a user perspective indeed map has the type (Int => Int) => BitSet. But map also has a more general type which can be inspected by clicking on another link.

We have not yet implemented functionality like this in our tools. But I believe we need to do this, to avoid scaring people off and to give more useful info. With tools like that, hopefully smart frameworks and libraries will not become suicide notes.

More Related Contents:

  1. Scala 2.8 breakOut
  2. Scala 2.8 collections design tutorial
  3. Scala Map implementation keeping entries in insertion order?
  4. What is a “context bound” in Scala?
  5. What do
  6. How to write to a file in Scala?
  7. Why is Scala’s immutable Set not covariant in its type?
  8. What is the difference between JavaConverters and JavaConversions in Scala?
  9. When should I choose Vector in Scala?
  10. What does param: _* mean in Scala?
  11. withFilter instead of filter
  12. What type to use to store an in-memory mutable data table in Scala?
  13. Scala pattern matching with lowercase variable name
  14. Stream vs Views vs Iterators
  15. How to read files from resources folder in Scala?
  16. Function returns an empty List in Spark
  17. Implementing yield (yield return) using Scala continuations
  18. Scala: Why does Seq.contains take an Any argument, instead of an argument of the sequence type?
  19. Reduce, fold or scan (Left/Right)?
  20. Overload constructor for Scala’s Case Classes?
  21. What are Scala continuations and why use them?
  22. Scala Sets contain the same elements, but sameElements() returns false
  23. Difference between MutableList and ListBuffer
  24. Scala: Parallel collection in object initializer causes a program to hang
  25. How can I convert immutable.Map to mutable.Map in Scala?
  26. When is @uncheckedVariance needed in Scala, and why is it used in GenericTraversableTemplate?
  27. Scala best way of turning a Collection into a Map-by-key?
  28. scala parallel collections degree of parallelism
  29. Why does pattern matching in Scala not work with variables?
  30. Linearization order in Scala

Leave a Comment