Scalaz Splitting eine Berechnung in Unterteile

Question

habe ich einen sehr großen List[A] und eine Funktion f: List[A] => List[B]. Ich würde gern Split meine ursprüngliche Liste in Teillisten mit einer maximalen Größe, um die Funktion zu jedem sublist wiederum anwenden und dann ungeteilt das Ergebnis in einer großen List[B]. Diese recht einfach:

def split[T](l : List[T], max : Int) : List[List[T]] = //TODO

def unsplit[T](l : List[List[T]]) : List[T] = //TODO

def apply[A, B](l : List[A], f : List[A] => List[B], max : Int) : List[B] = {
  unsplit(split(l, max).map(f(_)))
}

Ich habe mich gefragt, ob scalaz Standard-Sachen geliefert dies die Box tun aus? Insbesondere die apply Methode?

Answer 1

unsplit es nur MA#join, für jeden M[M[A]] wo M ein Monad ist.

split existiert nicht aus der Box. Es folgt eine Runde über Art und Weise, dies zu tun, mehr einige Scalaz Konzepte zu demonstrieren. Es löst tatsächlich einen Stapelüberlauf in den Compiler zur Zeit!

val ls = List(1, 2, 3, 4, 5)
val n = 5

def truesAndFalses(n: Int): Stream[Boolean] = 
  Stream.continually(true.replicate[Stream](n) |+| false.replicate[Stream](n)).join

val grouped: List[List[Int]] = {
  var zipped: List[(Int, Boolean)] = ls.zip(truesAndFalses(2))
  var groupedWithBools: List[List[(Int, Boolean)]] = zipped splitWith {_._2}
  groupedWithBools ∘∘ {pair: (Int, _) => pair._1}
}

val joined: List[Int] = grouped ∘∘ {_ * 2} join

Answer 2

Wie wäre es damit:

def split[T](ls: List[T],max: Int): List[List[T]] = ls.grouped(max).toList

def unsplit[T](ls: List[List[T]]): List[T] = ls.flatMap(identity)