Equality between StringOps and WrappedString instances - scala

Question

I'm just learning Scala so I apologize if this has already been discussed but the following seemed a bit odd to me:
scala> import scala.collection.immutable._
import scala.collection.immutable._
scala> val st1 = new WrappedString("Hello")
st1: scala.collection.immutable.WrappedString = Hello
scala> val st2 = new StringOps("Hello")
st2: scala.collection.immutable.StringOps = Hello
scala> st2 == st1
res0: Boolean = true
scala> st1 == st2
res1: Boolean = false
Can anyone explain this? I am using Scala version 2.10.0-M4. I haven't tried this with
anything other versions.

Answer 1

The reason why there occur differences is documented in ScalaDoc.
WrappedString:
The difference between this class and StringOps is that calling
transformer methods such as filter and map will yield an object of
type WrappedString rather than a String.
StringOps:
The difference between this class and WrappedString is that calling
transformer methods such as filter and map will yield a String
object, whereas a WrappedString will remain a WrappedString.
Both derive from collection.GenSeqLike which defines an equals method:
override def equals(that: Any): Boolean = that match {
case that: GenSeq[_] => (that canEqual this) && (this sameElements that)
case _ => false
}
Both implement the canEqual (derived from collection.IterableLike) which returns always true. But StringOps is not a collection.GenIterable:
scala> st1 sameElements st2
<console>:13: error: type mismatch;
found : scala.collection.immutable.StringOps
required: scala.collection.GenIterable[?]
st1 sameElements st2
^
Whereas WrappedString does:
scala> st2 sameElements st1
res13: Boolean = true
So it should obvious why the first case returns true and the other one false.
But why do both exist? I'm not totally sure why it is designed this way, but I think that's because of the fact that a String is not a collection in Scala. When we do some operation on a String like "abc" flatMap (_+"z") we wanna get back another String even though it is not always possible as shown by "abc" map (_+1). This is what StringOps does. But when we have some method def x[A](s: Seq[A]) = s.getClass how shall we call it with a String? In this case we need WrappedString:
scala> x("a")
res9: Class[_ <: Seq[Char]] = class scala.collection.immutable.WrappedString
So, StringOps is more lightweight as WrappedString. It allows us to call some methods on plain old java.lang.String without doing too much overhead. In 2.10 StringOps extend AnyVal. This means it is a value class and its existence can be optimized by scalac (no runtime overhead any more by wrapping the String). In contrast WrappedString allows us to handle a String as a real collection - as an IndexedSeq[Char].