Scalaz división un cálculo en sub-partes

Question

Tengo una muy grande y una List[A] f: List[A] => List[B] función. Quisiera Split mi lista original en sub-listas con un tamaño máximo, aplicar la función a cada sublista a su vez y luego sin dividir el resultado en un gran List[B]. Esto es bastante fácil:

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(_)))
}

Me estaba preguntando si scalaz suministrado material estándar de hacer esto fuera de la caja? En particular, el método apply?

Answer 1

unsplit sólo MA#join, para cualquier M[M[A]] donde M es un Monad.

split no existe fuera de la caja. La siguiente es una manera indirecta de hacer esto, más para demostrar algunos conceptos Scalaz. En realidad, provoca un desbordamiento de pila en el compilador en el momento!

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

¿Qué tal esto:

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)