1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
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 -> "?"))
}
}
|
