Como evitar que o futuro nunca termine

Suponha que eu tenha várias tarefas que desejo executar em paralelo.

Cada tarefa (método) tem uma função recursiva interna que basicamente busca dados de um banco de dados e os salva em algum armazenamento de dados.

[função recursiva interna simplificada]

 def simplifiedSomeTask(): Unit = {
    @scala.annotation.tailrec
    def get(
        stream: Stream[SomeEntity],
        result: Seq[SomeEntity],
    ): Stream[SomeEntity] = result match {
      case Nil =>
        stream
      case _ =>
        val query = //query to fetch data from database
        get(
          stream append result.toStream,
          query.run.value, // get fetched data from database
        )
    }

    val buffer = collection.mutable.Map.empty[String, String]

    get(
      Stream.empty,
      query.run.value
    ).foreach { r =>
      buffer.put(r.loginId, r.userId)
    }
  }

Ao tentar executar A, Future nunca termina por algum motivo.

[UMA]

val f1 =Future { someTask1() }
val f2 =Future { someTask2() }
val f3 =Future { someTask3() }

val f = for {
  _ <- f1 
  _ <- f2 
  _ <- f3 
} yield ()

Await.result(f, Duration.Inf)

No entanto, B funciona (embora não seja executado em paralelo)

[B]

val f = for {
  _ <- Future { someTask1() }
  _ <- Future { someTask2() }
  _ <- Future { someTask3() }
} yield ()

Await.result(f, Duration.Inf)

Como devo modificar A para que funcione conforme o esperado?