Multiple scala calls faster than tail recursive custom function - list

Question

I hope this is the right place for this question.
I wrote some code to improve collision detection on a 2D simulation. Part of this algorithm is to associate a list of objects to the specific 2D area where they belong. A function f: (Seq[Box], Seq[T]) => Map[Box, Seq[T]].
I first implemented it with native Scala functions like map, groupBy, ... but then I needed it to return also Boxes with empty Seq[T] and groupBy doesn't do that, so I wrote a recursive function that in my view should be faster that the previous one (this might be me not knowing a better way but this is not the main question).
It turns out that my tail recursive implementation is computationally slower than the one using Scala libraries, its execution time grows faster than the other (benchmarked). I don't understand why, can someone point me to the reason?
def spreadAcrossFast[T](
nodes: Seq[Box],
objects: Seq[T]
) = {
// I create the pairs (reference box, objects that intersects the box)
// intersects() is called nodes.size * object.size times
val assigned = for (
b ← nodes;
s ← objects if intersects( b, s )
) yield ( b, s )
// Group by Box and clean the format of the association above
assigned
// Should be O(n*Log n)
.groupBy( _._1 )
// Maximum nodes.size iterations
.map { x ⇒
// Can consider objects.size / nodes.size iterations
( x._1, x._2.map( _._2 ) )
}
}
def spreadAcrossSlow[T](
nodes: Seq[Box],
objects: Seq[T],
compact: Boolean = true // If compact == true, don't include in the output Box that
) = { // have empty content
#tailrec
def loop( boxes: Seq[Box], acc: Map[Box, Seq[T]] ): Map[Box, Seq[T]] = boxes match {
// End of the boxes, return the accumulator
case Nil ⇒ acc
// Get the objects that intersect the box and add them to the accumulator
case b +: bs ⇒
// Every call it goes through objects.size items
// intersects() is called nodes.size * object.size times
val objInBox = objects.filter( intersects( b, _ ) )
val newAcc = if ( objInBox.isEmpty && compact ) acc else acc + ( ( b, objInBox ) )
loop( bs, newAcc )
}
// nodes.size iterations
loop( nodes, Map.empty[Box, Seq[T]] )
}
Seq is an instance of List.
From my point of view spreadAcrossFast has more iterations than spreadAcrossSlow and the most expensive operation, intersects(), is called the same number of times, nodes.size * objects.size
UPDATE: No luck even with (but the code is cleaner):
def spreadAcrossSlow[T: SpatialIndexable](
nodes: Seq[Box], objects: Seq[T], compact: Boolean
): Map[Box, Seq[T]] = {
val acc = scala.collection.mutable.HashMap[Box, Seq[T]]()
for ( b ← nodes ) {
val objInBox = objects.filter( intersects( b, _ ) )
if ( objInBox.nonEmpty || !compact ) acc += ( ( b, objInBox ) )
}
acc.toMap
}