Scalaz fractionnement d'un calcul en sous-parties

Question

J'ai un très grand List[A] et une fonction f: List[A] => List[B]. Je voudrais divisé ma liste originale en sous-listes avec une taille maximale, appliquez la fonction à chaque sous-liste à tour de rôle, puis non divisé le résultat en un grand List[B]. Ce assez facile:

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

Je me demandais si scalaz fourni des trucs standard pour faire de la boîte? En particulier la méthode apply?

Answer 1

unsplit juste MA#join, pour tout M[M[A]] où M est un Monad.

split n'existe pas en dehors de la boîte. Ce qui suit est un tour sur la façon de le faire, plus pour démontrer quelques concepts Scalaz. Il déclenche actuellement un débordement de pile dans le compilateur pour le moment!

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

Que diriez-vous ceci:

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)