Part 1: Followup of the FP meetup "Abstractions of higher kind" - using ValidatedNel

example-with-traverse-and-validated-nel.scala

import cats._
import cats.data._
import cats.implicits._

case class User(age: Int)

def complicatedFunction[F[_]: Traverse, G[_]: Applicative, A: Monoid](ids: F[Int], fetchUser: Int => G[User], consume: User => A): G[A] = {
  ids.traverse(fetchUser)
    .map(_.foldMap(consume))
}

def fetchUserFromMem(i: Int): ValidatedNel[String, User] = {
  i match {
    case 1 => User(25).validNel
    case 2 => User(25).validNel
    case 3 => User(33).validNel
    case _ => s"User with id $i not found".invalidNel
  }
}

val validIds = List(1, 2, 3)
val invalidIds = List(21, 22, 1, 2, 3)

complicatedFunction(validIds, fetchUserFromMem, u => Map(u.age -> 1))
// Valid(Map(25 -> 2, 33 -> 1))

complicatedFunction(invalidIds, fetchUserFromMem, u => Map(u.age -> 1))
// Invalid(NonEmptyList(User with id 21 not found, User with id 22 not found))

The problem is how can we have all the errors and still produce results whenever possible?