Project Euler 23 in Scala (non-abundant sums)
I was able to reduce the run time of your code to a few seconds (2 seconds on my computer) by changing the type of abundant from a List to an immutable Set. 

You were correct that !abundantList.exists(x =&gt; abundantList.contains(num - x)) was the major bottleneck in your code. 

This is a bottleneck because checking that an item exists in a List means inspecting every item in the List until we find it or reach the end of the List. Fortunately we can use a Set (which under the hood is supported by the immutable.HashMap class) and reduce the search time for objects from linear to effectively constant. 

Notice that in the code below I simply applied the method toSet to your abundance function converting the returned List to a Set.

val abundant = abundance(3, List()).toSet

def notSumAbundant(num: Int, currentList: List[Int]): List[Int] = {
  if(num &lt;= n) {
    val abundantSet: Set[Int] = abundant.filter(_ &lt; num)
    if (!abundantSet.exists(x =&gt; abundantSet.contains(num - x))) {
      notSumAbundant(num + 1, num :: currentList)
    } else
      notSumAbundant(num + 1, currentList)
  } else
    currentList
}


For more information check out this nice write up on Scala collections that is co-written by the creator of Scala, Martin Odersky.