conflict resolution

Author: pietrotull

compat/src/main/scala-2.11/scala/collection/compat/package.scala

@@ -13,7 +13,9 @@
 package scala.collection
 
 import scala.collection.generic.{CanBuildFrom, GenericOrderedCompanion, IsTraversableLike}
+
 import scala.runtime.Tuple2Zipped
+import scala.collection.{immutable => i}
 import scala.{collection => c}
 
 package object compat extends compat.PackageShared {
@@ -49,4 +51,8 @@ package object compat extends compat.PackageShared {
 	implicit def toTuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2](self: Tuple2Zipped[El1, Repr1, El2, Repr2])
 	: Tuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2] =
 		new Tuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2](self)
+  implicit def toImmutableQueueExtensionMethods[A](
+      self: i.Queue[A]): ImmutableQueueExtensionMethods[A] =
+    new ImmutableQueueExtensionMethods[A](self)
+
 }

compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala

@@ -329,6 +329,21 @@ class TraversableLikeExtensionMethods[A, Repr](private val self: c.GenTraversabl
   def tapEach[U](f: A => U)(implicit bf: CanBuildFrom[Repr, A, Repr]): Repr =
     self.map(a => { f(a); a })
 
+  def partitionMap[A1, A2, That, Repr1, Repr2](f: A => Either[A1, A2])(
+      implicit bf1: CanBuildFrom[Repr, A1, Repr1],
+      bf2: CanBuildFrom[Repr, A2, Repr2]
+  ): (Repr1, Repr2) = {
+    val l = bf1()
+    val r = bf2()
+    self.foreach { x =>
+      f(x) match {
+        case Left(x1)  => l += x1
+        case Right(x2) => r += x2
+      }
+    }
+    (l.result(), r.result())
+  }
+
   def groupMap[K, B, That](key: A => K)(f: A => B)(
       implicit bf: CanBuildFrom[Repr, B, That]): Map[K, That] = {
     val map = m.Map.empty[K, m.Builder[B, That]]
@@ -392,3 +407,8 @@ class MapViewExtensionMethods[K, V, C <: scala.collection.Map[K, V]](
   def filterKeys(p: K => Boolean): IterableView[(K, V), C] =
     self.filter { case (k, _) => p(k) }
 }
+
+class ImmutableQueueExtensionMethods[A](private val self: i.Queue[A]) extends AnyVal {
+  def enqueueAll[B >: A](iter: c.Iterable[B]): i.Queue[B] =
+    self.enqueue(iter.to[i.Iterable])
+}

compat/src/main/scala-2.12/scala/collection/compat/package.scala

@@ -16,6 +16,8 @@ import scala.collection.generic.{CanBuildFrom, GenericOrderedCompanion, IsTraver
 import scala.{collection => c}
 import scala.collection.{mutable => m}
 import scala.runtime.Tuple2Zipped
+import scala.collection.{immutable => i, mutable => m}
+
 
 package object compat extends compat.PackageShared {
   implicit class MutableTreeMapExtensions2(private val fact: m.TreeMap.type) extends AnyVal {
@@ -60,5 +62,9 @@ package object compat extends compat.PackageShared {
 	implicit def toTuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2](self: Tuple2Zipped[El1, Repr1, El2, Repr2])
 	: Tuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2] =
 		new Tuple2ZippedExtensionMethods[El1, Repr1, El2, Repr2](self)
+
+  implicit def toImmutableQueueExtensionMethods[A](
+      self: i.Queue[A]): ImmutableQueueExtensionMethods[A] =
+    new ImmutableQueueExtensionMethods[A](self)
 }
 

compat/src/test/scala/test/scala/collection/CollectionTest.scala

@@ -36,8 +36,8 @@ class CollectionTest {
     val bT: BitSet = b
     assertEquals(BitSet(1, 2, 3), b)
 
-    val c          = xs.to(PriorityQueue)
-    val cT: PriorityQueue[Int]  = c
+    val c                      = xs.to(PriorityQueue)
+    val cT: PriorityQueue[Int] = c
     assert(PriorityQueue(1, 2, 3) sameElements c)
 
     val ys = List(1 -> "a", 2 -> "b")
@@ -48,8 +48,8 @@ class CollectionTest {
     assertTrue(m.isInstanceOf[Map[_, _]])
 
     // Stream.to(Seq) doesn't evaluate the stream
-    val strm = 1 #:: {throw new Exception("not lazy")} #:: Stream.empty[Int]
-    val strmsq: Seq[Int] = strm.to(Seq)
+    val strm                   = 1 #:: { throw new Exception("not lazy") } #:: Stream.empty[Int]
+    val strmsq: Seq[Int]       = strm.to(Seq)
     var strmln: LinearSeq[Int] = strm.to(LinearSeq)
   }
 
@@ -101,10 +101,23 @@ class CollectionTest {
     assertEquals(Map(3 -> 3, 4 -> 1), res)
   }
 
+  @Test
+  def partitionMapTest(): Unit = {
+    val empty = Seq.empty[Int].partitionMap(Right(_))
+    assertEquals((Seq(), Seq()), empty)
+
+    val res = Seq("foo", "test", "bar", "baz")
+      .partitionMap {
+        case s if s.contains("a") => Left(s)
+        case s                    => Right(s.length)
+      }
+    assertEquals((Seq("bar", "baz"), Seq("foo".length, "test".length)), res)
+  }
+
   @Test
   def tapEach(): Unit = {
     var count = 0
-    val it = Iterator(1, 2, 3).tapEach(count += _)
+    val it    = Iterator(1, 2, 3).tapEach(count += _)
     assertEquals(0, count)
     it.foreach(_ => ())
     assertEquals(6, count)

compat/src/test/scala/test/scala/collection/ImmutableQueueTest.scala

@@ -0,0 +1,30 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package test.scala.collection
+
+import org.junit.Assert._
+import org.junit.Test
+
+import scala.collection.compat._
+import scala.collection.immutable.Queue
+
+class ImmutableQueueTest {
+
+  @Test
+  def testEnqueueAll: Unit = {
+    val q                = Queue(1, 2)
+    val i: Iterable[Int] = List(3, 4)
+    val eq               = q.enqueueAll(i)
+    assertEquals(Queue(1, 2, 3, 4), eq)
+  }
+}

compat/src/test/scala/test/scala/collection/LazyZipTest.scala

@@ -1,8 +1,6 @@
 package test.scala.collection
 
 import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.assertFalse
 import org.junit.Test
 
 import scala.collection.compat._