Jak zrozumieć biegu traverseU i traverseM

Question

Jestem zagubiony przypadku użytkowania na temat biegu traverseU i traverseM, szukałem go na stronie internetowej scalaz, prosty przykład kodu:

def sum(x: Int) = x + 1 

List(1,2,3).traverseU(sum) 

wygląda to podobna do (mapa i kruszywa):

List(1,2,3).map(sum).reduceLeft(_ + _) 

myślę, że jest bardziej niż dla traverseU, ja po prostu zastanawiam się, jaka jest różnica między tymi 3 metody, byłoby lepiej będę mieć jakiś przykładowy kod, aby pokazać różnica

Wiele z góry dzięki

Answer 1

sequence służy do zgromadzić efektów aplikacyjnych. Bardziej konkretnie, pozwala "przerzucić" F[G[A]] na G[F[A]], pod warunkiem, że G jest Applicative i F jest Traversable. Więc możemy użyć go do „współdziałać” pęczek Applicative efektów (uwaga wszystkich Monad s są Applicative):

List(Future.successful(1), Future.successful(2)).sequence : Future[List[Int]] 
// = Future.successful(List(1, 2)) 
List(4.set("abc"), 5.set("def")).sequence : Writer[String, List[Int]] 
// = List(4, 5).set("abcdef") 

traverse jest równoważna map następnie sequence, więc można go używać, gdy masz funkcję zwraca Applicative i chcesz po prostu jedno wystąpienie swoimi Applicative zamiast listy z nich:

def fetchPost(postId: Int): Future[String] 
//Fetch each post, but we only want an overall `Future`, not a `List[Future]` 
List(1, 2).traverse[Future, String](fetchPost): Future[List[String]] 

traverseU jest taka sama operacja jak traverse , tylko z typami wyrażonymi w inny sposób, aby kompilator mógł łatwiej ich wywnioskować.

def logConversion(s: String): Writer[Vector[String], Int] = 
    s.toInt.set(Vector(s"Converted $s")) 
List("4", "5").traverseU(logConversion): Writer[Vector[String], List[Int]] 
// = List("4", "5").map(logConversion).sequence 
// = List(4.set("Converted 4"), 5.set("Converted 5")).sequence 
// = List(4, 5).set(Vector("Converted 4", "Converted 5")) 

traverseM(f) jest równoważna traverse(f).map(_.join), gdzie join jest nazwą scalaz dla flatten. Jest to użyteczne jako swego rodzaju „podnoszenia flatMap”:

def multiples(i: Int): Future[List[Int]] = 
    Future.successful(List(i, i * 2, i * 3)) 
List(1, 10).map(multiples): List[Future[List[Int]]] //hard to work with 
List(1, 10).traverseM(multiples): Future[List[Int]] 
// = List(1, 10).traverse(multiples).map(_.flatten) 
// = List(1, 10).map(multiples).sequence.map(_.flatten) 
// = List(Future.successful(List(1, 2, 3)), Future.successful(List(10, 20, 30))) 
//  .sequence.map(_.flatten) 
// = Future.successful(List(List(1, 2, 3), List(10, 20, 30))).map(_.flatten) 
// = Future.successful(List(1, 2, 3, 10, 20, 30))