我不认为这是可能的，对不起。
一个Future[List[T]]可以用一个空列表、一个包含一个元素的列表或任意多个元素的列表来完成。
如果你把它转换成List[Future[T]]，那么这个列表会包含多少个Futures？

而不是使用akkas pipeTo模式，你可以做一些像这样的事情：

// capture the sender, before the future is started - just like pipeTo does
val s = sender()
futureOfListOfFoo.foreach { listOfFoo =>
  listOfFoo.map(convertToMessage).foreach { foo => s ! foo }
}

你为什么要这么做？你想达到什么目的？一旦你的未来解决了，列表中的所有项目都是可用的，所以你通过将它们中的每一个提升到自己的未来中来获得很少。
总之：

import scala.concurrent._
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

// Assuming some starting future.
val foo: Future[List[String]] = Future.successful(List("foo"))

// This is pointless, because all we're doing is lifting each item in the list into its own already resolved future.
val bar: Future[List[Future[String]]] = foo.map(_.map(Future.successful))

// NB: you shouldn't use Await.
val baz: List[Future[String]] = Await.result(bar, 0.nanos)

我找不到Future.InverseSequence，但这可能是一个实现。

def inverseSequence[A](future: Future[Seq[A]])(implicit ec: ExecutionContext): Seq[Future[A]] = 
  future.flatMap(seq => Future.traverse(seq)(Future.successful))