Scala Future utilities to process elements asynchronous one after another

FutureUtils.scala

import scala.concurrent.{ExecutionContext, Future}

object FutureUtils {
  /**
   * Process elements asynchronous one after another.
   * Equivalent to `Future.sequence(elements.map(transform))`
   * but doing the processing sequentially instead of in parallel
   */
  def mapAsyncSequentially[TInput, TResult](elements: Iterable[TInput])
                                (mapFunction: TInput => Future[TResult])
                                (implicit executionContext: ExecutionContext) : Future[Seq[TResult]] = {
    val initial: Future[Seq[TResult]] = Future.successful(Seq())

    elements
      .foldLeft(initial) { (previousFuture, element) =>
        previousFuture.flatMap { results =>
          // when the previous Future is completed I run the next one
          mapFunction(element).map(results :+ _)
        }
      }
  }
}

FutureUtilsSpec.scala

import org.scalatest.funspec.AsyncFunSpec
import org.scalatest.matchers.should.Matchers

import scala.concurrent.Future

class FutureUtilsSpec extends AsyncFunSpec with Matchers {
  describe("mapAsyncSequentially") {
    it("should be equivalent to Future.sequence") {
      val elements = Seq(1, 2, 3, 4, 5, 6, 7, 8, 9)

      FutureUtils.mapAsyncSequentially(elements) { element =>
        Future(element * 10)
      }.map { results =>
        results should be (elements.map(_ * 10))
      }
    }
  }
}