scala timing problems with add stuff to a seq - scala

Question

I've got a question that concerns scoping in scala. I have a function like this:
def getElements(id: Int): Seq[Element] = {
var test = ""
dto.getElementIds(id).map {
elementIds => {
test += " hello "
elementIds.foreach(elementId => dto.getElement(elementId).map {
case Some(element) => test += " hi "
println("ThirdPrint: " + test)
})
println("SecondPrint: " + test)
}
}
println("FirstPrint: " + test)
}
Lets say "elementsIds" has a lenght of 2.
The console says:
FirstPrint:
SecondPrint: hello
ThirdPrint: hello hi
ThirdPrint: hello hi hi
Why is scala doing that? I would assume that third print is executed first. By the time I get to the "FirstPrint" the "hi"'s are gone. Why is the last line of code executed first?
I'm working with slick and Futures, does this have something to do with it? Thanks!
UPDATE
Thanks, works fine.
Is it possible to return a seq instead? Like this:
def getElements(id: Int): Future[Seq[Element]] = {
var mySequence: Seq[Element] = Seq()
val elementsIds: Future[Seq[Int]] = dto.getElementIds(id)
var test = ""
val elementsF = elementsIds.flatMap {
elementIds => {
test += " hello "
val idsAsElements: Seq[Future[Element]] = elementIds.map(elementId => dto.getElement(elementId).collect {
case Some(element) => mySequence = mySequence :+ element
})
val idsAsElementsF: Future[Seq[Element]] = Future.sequence(idsAsElements)
idsAsElementsF.onComplete(_ => println("SecondPrint: " + test))
idsAsElementsF
}
}
elementsF.onComplete(_ => println("FirstPrint: " + test))
elementsF
}
Is it possible to return "mySequence" whenever idsAsElements is "onComplete"?

Answer 1

object X {
import scala.concurrent.ExecutionContext.Implicits.global
case class Element()
object dto{
def getElementIds(i: Int): Future[Seq[Int]] = Future(Seq(1,2,3))
def getElement(i: Int): Future[Option[Element]] = Future(Some(Element()))
}
def main(args: Array[String]): Unit = {
getElements(0)
Thread.sleep(10000) // waiting logs
}
def getElements(id: Int): Future[Seq[Element]] = {
val elementsIds: Future[Seq[Int]] = dto.getElementIds(id)
var test = ""
val elementsF = elementsIds.flatMap {
elementIds => {
test += " hello "
val idsAsElements: Seq[Future[Element]] = elementIds.map(elementId => dto.getElement(elementId).collect {
case Some(element) => test += " hi "
println("ThirdPrint: " + test)
element
})
val idsAsElementsF: Future[Seq[Element]] = Future.sequence(idsAsElements)
idsAsElementsF.onComplete(_ => println("SecondPrint: " + test))
idsAsElementsF
}
}
elementsF.onComplete(_ => println("FirstPrint: " + test))
elementsF
}
}
output:
ThirdPrint: hello hi
ThirdPrint: hello hi hi
ThirdPrint: hello hi hi hi
SecondPrint: hello hi hi hi
FirstPrint: hello hi hi hi

Answer 2

Yes, that's not a good solution. You should avoid blocking in your code, except, maybe at the highest possible level (main method). Also, mutable state is bad, especially, when combined with concurrency (futures).
Your function should return a Future. Something like this will work (I am not sure if I guess the intent of your code correctly - your function was declared to return Seq[Element], but written to return a Unit ... I assume, that what you really wanted to return was the result of getElement calls for every id):
def getElements(id: Int): Future[Seq[Element]] = dto
.getElementIds(id)
.map { ids => ids.map(dto.getElement) }
.flatMap(Future.sequence)
.map(_.flatten)
I removed your printouts, because wasn't sure what was the purpose they serve (since the calls to dto.getElement are also happening in parallel, it is not obvious where and in which order you want those strings printed).
You could simulate your "expected output", by adding another transformation at the end for example:
.andThen { case Success(results) =>
val str = results.foldLeft("hello") { case (a,b) =>
println("ThirdPrint: " + a + " hi")
a + " hi"
}
println("SecondPrint: " + str)
println("FirstPrint: " + str
}