Добавление пользовательских операций сбора в Scala 2.13 в произвольные коллекции определенных типов

Question

Примечание: описанная ниже операция теперь существует в стандартной библиотеке как partitionMap но я считаю, что это все еще актуальный вопрос о том, как достичь более общих целей

Вопрос относительно scala 2.13 - как использовать / конструировать коллекции определенных типов при добавлении пользовательских операций с коллекциями, когда мне нужно ограничить типы элементов входных коллекций? Например, как я могу определить:

def split[CC[_], A, B](coll: CC[Either[A, B]]): (CC[A], CC[B])

Следуя документации, мне удалось добиться этого следующим образом:

import collection.generic.IsIterable
import scala.collection.{BuildFrom, Factory}

class SplitOperation[Repr, S <: IsIterable[Repr]](coll: Repr, itr: S) {
  def split[A, B, AS, BS](
    implicit bfa: BuildFrom[Repr, A, AS], 
             bfb: BuildFrom[Repr, B, BS], 
             ev: itr.A =:= Either[A, B]): (AS, BS) = {

    val ops = itr(coll)
    val as = bfa.fromSpecific(coll)(ops.iterator.map(ev).collect { case Left(a) => a })
    val bs = bfb.fromSpecific(coll)(ops.iterator.map(ev).collect { case Right(b) => b })

    (as, bs)
  }
}

implicit def SplitOperation[Repr](coll: Repr)(implicit itr: IsIterable[Repr]): SplitOperation[Repr, itr.type] =
new SplitOperation(coll, itr)

Тем не менее, мне нужно предоставить типы на сайте использования, в противном случае я получаю неявное расширение.

scala> List(Left("bah"), Right(1), Left("gah"), Right(2), Right(3))
res1: List[scala.util.Either[String,Int]] = List(Left(bah), Right(1), Left(gah), Right(2), Right(3))

scala> res1.split
            ^
       error: diverging implicit expansion for type scala.collection.BuildFrom[List[scala.util.Either[String,Int]],A,AS]

Но следующие работы:

scala> res1.split[String, Int, List[String], List[Int]]
res4: (List[String], List[Int]) = (List(bah, gah),List(1, 2, 3))

РЕДАКТИРОВАТЬ

class SplitOperation[X, CC[_], S <: IsIterable[CC[X]]](coll: CC[X], itr: S) {
  def split[A, B](implicit bfa: BuildFrom[CC[X], A, CC[A]], bfb: BuildFrom[CC[X], B, CC[B]], ev: itr.A =:= Either[A, B]): (CC[A], CC[B]) = {
    val ops = itr(coll)
    val as = bfa.fromSpecific(coll)(ops.iterator.map(ev).collect { case Left(a) => a })
    val bs = bfb.fromSpecific(coll)(ops.iterator.map(ev).collect { case Right(b) => b })

    (as, bs)
  }
}

implicit def SplitOperation[A, B, CC[_]](coll: CC[Either[A, B]])(implicit itr: IsIterable[CC[Either[A, B]]]): SplitOperation[Either[A, B], CC, itr.type] =
  new SplitOperation(coll, itr)

Дает мне небольшое улучшение. Теперь мне нужно только указать параметры типа A а также B на сайте вызова:

scala> l.split[String, Int]
res2: (List[String], List[Int]) = (List(bah, gah),List(1, 2))

Answer 1

Это похоже на работу:

class SplitOperation[A, B, CC[_], S <: IsIterable[CC[Either[A, B]]]](coll: CC[Either[A, B]], itr: S) {
  def split(implicit bfa: BuildFrom[CC[Either[A, B]], A, CC[A]], bfb: BuildFrom[CC[Either[A, B]], B, CC[B]], ev: itr.A =:= Either[A, B]): (CC[A], CC[B]) = {
    val ops = itr(coll)
    val as = bfa.fromSpecific(coll)(ops.iterator.map(ev).collect { case Left(a) => a })
    val bs = bfb.fromSpecific(coll)(ops.iterator.map(ev).collect { case Right(b) => b })

    (as, bs)
  }
}

implicit def SplitOperation[A, B, CC[_]](coll: CC[Either[A, B]])(implicit itr: IsIterable[CC[Either[A, B]]]): SplitOperation[A, B, CC, itr.type] =
  new SplitOperation(coll, itr)

Answer 2

В вашем случае вы не хотите абстрагироваться от "вида" конструктора типа коллекции (CC[_] против CC[_, _]и т. д.), вы всегда используете CC[_] добрый, поэтому вам не нужно использовать IsIterable.

Я думаю, что также необязательно поддерживать "Сортированные" коллекции (например, SortedSet) потому что нет Ordering пример для Either, поэтому вам не нужно использовать BuildFrom.

implicit class SplitOperation[A, B, CC[X] <: IterableOps[X, CC, CC[X]]](coll: CC[Either[A, B]]) {
  def split: (CC[A], CC[B]) = {
    val as = coll.iterableFactory.from(coll.iterator.collect { case Left(a) => a })
    val bs = coll.iterableFactory.from(coll.iterator.collect { case Right(b) => b })
    (as, bs)
  }
}

https://scastie.scala-lang.org/64QxHwteQN2i3udSxCa3yw