Scala Partition/Collect Usage

Nie wiem, jak to zrobić z collect bez użycia mutowalnych list, ale partition może również używać dopasowania wzorców (tylko trochę bardziej wyrazistych)

List("a", 1, 2, "b", 19).partition { 
  case s:String => true
  case _ => false 
}

Podpis normalnie używanego collect na, powiedzmy, Seq, to

collect[B](pf: PartialFunction[A,B]): Seq[B]

Co jest naprawdę szczególnym przypadkiem

collect[B, That](pf: PartialFunction[A,B])(
  implicit bf: CanBuildFrom[Seq[A], B, That]
): That

Więc jeśli używasz go w trybie domyślnym, odpowiedź brzmi nie, z pewnością nie: otrzymujesz z niego dokładnie jedną sekwencję. Jeśli zastosujesz CanBuildFrom przez Builder, zobaczysz, że możliwe byłoby, aby That były w rzeczywistości dwiema sekwencjami, ale nie można powiedzieć, do której sekwencji powinien wejść element, ponieważ funkcja częściowa może tylko powiedzieć " tak, należę" albo "nie, nie należę".

Więc co zrobić, jeśli chcesz mieć wiele warunków, które skutkują podzieleniem listy na kilka różnych części? Jednym ze sposobów jest utworzenie funkcji wskaźnika A => Int, gdzie twoja A jest mapowana do numerowanej klasy, a następnie użyj groupBy. Na przykład:

def optionClass(a: Any) = a match {
  case None => 0
  case Some(x) => 1
  case _ => 2
}
scala> List(None,3,Some(2),5,None).groupBy(optionClass)
res11: scala.collection.immutable.Map[Int,List[Any]] = 
  Map((2,List(3, 5)), (1,List(Some(2))), (0,List(None, None)))

Teraz możesz przeglądać swoje listy podrzędne według klas (w tym przypadku 0, 1 i 2). Niestety, jeśli chcesz zignorować niektóre wejścia, nadal musisz umieścić je w klasie (np. prawdopodobnie nie obchodzi mnie wiele kopii None w tym przypadku).

Używam tego. Jedną miłą rzeczą jest to, że łączy partycjonowanie i mapowanie w jednej iteracji. Jedną z wad jest to, że przydziela kilka tymczasowych obiektów (instancje Either.Left i Either.Right)

/**
 * Splits the input list into a list of B's and a list of C's, depending on which type of value the mapper function returns.
 */
def mapSplit[A,B,C](in: List[A])(mapper: (A) => Either[B,C]): (List[B], List[C]) = {
  @tailrec
  def mapSplit0(in: List[A], bs: List[B], cs: List[C]): (List[B], List[C]) = {
    in match {
      case a :: as =>
        mapper(a) match {
          case Left(b)  => mapSplit0(as, b :: bs, cs     )
          case Right(c) => mapSplit0(as, bs,      c :: cs)
        }
      case Nil =>
        (bs.reverse, cs.reverse)
    }
  }

  mapSplit0(in, Nil, Nil)
}

val got = mapSplit(List(1,2,3,4,5)) {
  case x if x % 2 == 0 => Left(x)
  case y               => Right(y.toString * y)
}

assertEquals((List(2,4),List("1","333","55555")), got)

Nie mogłem znaleźć satysfakcjonującego rozwiązania tego podstawowego problemu. Nie potrzebuję wykładu o collect i nie obchodzi mnie, czy to czyjeś zadanie domowe. Poza tym, nie chcę czegoś, co działa tylko dla List.

implicit class TraversableOnceHelper[A,Repr](private val repr: Repr)(implicit isTrav: Repr => TraversableOnce[A]) {

  def collectPartition[B,Left](pf: PartialFunction[A, B])
  (implicit bfLeft: CanBuildFrom[Repr, B, Left], bfRight: CanBuildFrom[Repr, A, Repr]): (Left, Repr) = {
    val left = bfLeft(repr)
    val right = bfRight(repr)
    val it = repr.toIterator
    while (it.hasNext) {
      val next = it.next
      if (!pf.runWith(left += _)(next)) right += next
    }
    left.result -> right.result
  }

  def mapSplit[B,C,Left,Right](f: A => Either[B,C])
  (implicit bfLeft: CanBuildFrom[Repr, B, Left], bfRight: CanBuildFrom[Repr, C, Right]): (Left, Right) = {
    val left = bfLeft(repr)
    val right = bfRight(repr)
    val it = repr.toIterator
    while (it.hasNext) {
      f(it.next) match {
        case Left(next) => left += next
        case Right(next) => right += next
      }
    }
    left.result -> right.result
  }
}

Przykładowe zastosowania:

val (syms, ints) =
  Seq(Left('ok), Right(42), Right(666), Left('ko), Right(-1)) mapSplit identity

val ctx = Map('a -> 1, 'b -> 2) map {case(n,v) => n->(n,v)}
val (bound, unbound) = Vector('a, 'a, 'c, 'b) collectPartition ctx
println(bound: Vector[(Symbol, Int)], unbound: Vector[Symbol])