diff options
author | Aleksandar Prokopec <axel22@gmail.com> | 2012-06-27 16:30:35 +0200 |
---|---|---|
committer | Aleksandar Prokopec <axel22@gmail.com> | 2012-06-27 16:30:35 +0200 |
commit | 5362f3df48a363308e41434b17fca60a0d4d84da (patch) | |
tree | e493caacebcaf04f194ca52fa7c2033a6f47db55 /test | |
parent | 9a28ee1ffc085bc680c48b12ad632b9133adf020 (diff) | |
download | scala-5362f3df48a363308e41434b17fca60a0d4d84da.tar.gz scala-5362f3df48a363308e41434b17fca60a0d4d84da.tar.bz2 scala-5362f3df48a363308e41434b17fca60a0d4d84da.zip |
Fix SI-3326.
The heart of the problem - we want to retain the ordering when
using `++` on sorted maps.
There are 2 `++` overloads - a generic one in traversables and
a map-specific one in `MapLike` - which knows about the ordering.
The problem here is that the expected return type for the expression
in which `++` appears drives the decision of the overload that needs
to be taken.
The `collection.SortedMap` does not have `++` overridden to return
`SortedMap`, but `immutable.Map` instead.
This is why `collection.SortedMap` used to resort to the generic
`TraversableLike.++` which knows nothing about the ordering.
To avoid `collection.SortedMap`s resort to the more generic `TraverableLike.++`,
we override the `MapLike.++` overload in `collection.SortedMap` to return
the proper type `SortedMap`.
Diffstat (limited to 'test')
-rw-r--r-- | test/files/run/t3326.check | 8 | ||||
-rw-r--r-- | test/files/run/t3326.scala | 74 |
2 files changed, 82 insertions, 0 deletions
diff --git a/test/files/run/t3326.check b/test/files/run/t3326.check new file mode 100644 index 0000000000..d0e11cebf7 --- /dev/null +++ b/test/files/run/t3326.check @@ -0,0 +1,8 @@ +Map(2 -> Hello, 1 -> World) +Map(5 -> Foo, 4 -> Bar) +Map(5 -> Foo, 4 -> Bar, 2 -> Hello, 1 -> World) +Map(3 -> ?, 2 -> Hello, 1 -> World) +Map(2 -> Hello, 1 -> World) +Map(5 -> Foo, 4 -> Bar) +Map(5 -> Foo, 4 -> Bar, 2 -> Hello, 1 -> World) +Map(3 -> ?, 2 -> Hello, 1 -> World)
\ No newline at end of file diff --git a/test/files/run/t3326.scala b/test/files/run/t3326.scala new file mode 100644 index 0000000000..f70cb01504 --- /dev/null +++ b/test/files/run/t3326.scala @@ -0,0 +1,74 @@ + + + +import scala.math.Ordering + + + +/** The heart of the problem - we want to retain the ordering when + * using `++` on sorted maps. + * + * There are 2 `++` overloads - a generic one in traversables and + * a map-specific one in `MapLike` - which knows about the ordering. + * + * The problem here is that the expected return type for the expression + * in which `++` appears drives the decision of the overload that needs + * to be taken. + * The `collection.SortedMap` does not have `++` overridden to return + * `SortedMap`, but `immutable.Map` instead. + * This is why `collection.SortedMap` used to resort to the generic + * `TraversableLike.++` which knows nothing about the ordering. + * + * To avoid `collection.SortedMap`s resort to the more generic `TraverableLike.++`, + * we override the `MapLike.++` overload in `collection.SortedMap` to return + * the proper type `SortedMap`. + */ +object Test { + + def main(args: Array[String]) { + testCollectionSorted() + testImmutableSorted() + } + + def testCollectionSorted() { + import collection._ + val order = implicitly[Ordering[Int]].reverse + var m1: SortedMap[Int, String] = SortedMap.empty[Int, String](order) + var m2: SortedMap[Int, String] = SortedMap.empty[Int, String](order) + + m1 += (1 -> "World") + m1 += (2 -> "Hello") + + m2 += (4 -> "Bar") + m2 += (5 -> "Foo") + + val m3: SortedMap[Int, String] = m1 ++ m2 + + println(m1) + println(m2) + println(m3) + + println(m1 + (3 -> "?")) + } + + def testImmutableSorted() { + import collection.immutable._ + val order = implicitly[Ordering[Int]].reverse + var m1: SortedMap[Int, String] = SortedMap.empty[Int, String](order) + var m2: SortedMap[Int, String] = SortedMap.empty[Int, String](order) + + m1 += (1 -> "World") + m1 += (2 -> "Hello") + + m2 += (4 -> "Bar") + m2 += (5 -> "Foo") + + val m3: SortedMap[Int, String] = m1 ++ m2 + + println(m1) + println(m2) + println(m3) + + println(m1 + (3 -> "?")) + } +} |