使用列表作为累加器的折叠方法

Question

To find prime factors of a number I was using this piece of code :

 def primeFactors(num: Long): List[Long] = {
   val exists = (2L to math.sqrt(num).toLong).find(num % _ == 0)
    exists match {
     case Some(d) => d :: primeFactors(num/d)
     case None => List(num)
  }
}

but this I found a cool and more functional approach to solve this using this code:

def factors(n: Long): List[Long] = (2 to math.sqrt(n).toInt)
.find(n % _ == 0).fold(List(n)) ( i => i.toLong :: factors(n / i)) 

Earlier I was using foldLeft or fold simply to get sum of a list or other simple calculations, but here I can't seem to understand how fold is working and how this is breaking out of the recursive function.Can somebody plz explain how fold functionality is working here.

Answer 1

Option's fold

If you look at the signature of Option 's fold function, it takes two parameters:

def fold[B](ifEmpty: => B)(f: A => B): B

What it does is, it applies f on the value of Option if it is not empty. If Option is empty, it simply returns output of ifEmpty (this is termination condition for recursion).

So in your case, i => i.toLong :: factors(n / i) represents f which will be evaluated if Option is not empty. While List(n) is termination condition.

fold used for collection / iterators

The other fold that you are taking about for getting sum of collection, comes from TraversableOnce and it has signature like:

def foldLeft[B](z: B)(op: (B, A) => B): B

Here, z is starting value (suppose incase of sum it's 0 ) and op is associative binary operator which is applied on z and each value of collection from left to right.

So both fold s differ in their implementation.