Scala comment appeler une fonction future sur les articles de HashMap

khan7:

J'ai un hashmap map: Map[A, Seq[B]]et je veux appeler une fonction future (que de retour Future[Either[Error, Unit]]) pour chaque Bma carte.

Par exemple, compte tenu de la fonction suivante def fooFunc(hashMap: Map[A, Seq[B]]): Future[Either[Error, Unit]]

J'ai essayé quelque chose comme

def fooFunc(hashMap: Map[A, Seq[B]]): Future[Either[Error, Unit]] = {
  val result = for {
   _ <- hashMap.map(entry => 
          entry._2.map( value => 
            Future.sequence(futureFunc(value, entry._1)).liftF
          )
        )
   } yield ()
  result.value
}

ce qui donne l'erreur de compilation Type mismatch, expected: NotInferedM[Future[NotInferedA]], actual: [Future[Either[Error, Unit]]]

C'est la première fois face à l'avenir et itérer sur hashmap, donc je suis confus comment aller exactement à ce sujet et accord avec le Iterable. Des conseils seraient appréciés

Mario Galic:

Nous pouvons cartographier sur une HashMapcomme tout autre collection tels queList

m.flatMap({ case (key, values) => values.map(f(_, key)) })

où m: Map[A, Seq[B]]et f: (B, A) => Future[Unit]. Ce rendement Iterable[Future[Unit]]afin que nous puissions utiliser Future.sequencepour inverser laFuture[Iterable[Unit]]

m
  .flatMap({ case (key, values) => values.map(f(_, key)) })
  .pipe(Future.sequence(_))

À terme représentent interne succès / échec à l' aide Tryque nous pouvons convertir à l' Eitheraide transformet toEithercomme si

m                                                           // : Map[A, Seq[B]]
  .flatMap({ case (key, values) => values.map(f(_, key)) }) // : Iterable[Future[Unit]]
  .pipe(Future.sequence(_))                                 // : Future[Iterable[Unit]]
  .map(_ => ())                                             // : Future[Unit]
  .transform(tryResult => Success(tryResult.toEither))      // : Future[Either[Throwable, Unit]]

qui renvoie le requis de Future[Either[Error, Unit]]type. La pipeméthode vient deimport util.chaining._

^{Personnellement, la transformation de Map[A, Seq[B]]la Future[Either[Error, Unit]], se sent un peu suspect.}