Is there an equivalent to python reduce() function in scala?

Question

I've just started learning Scala and functional programming and I'm trying to convert the following from Python to Scala:

def immutable_iterative_fibonacci(position):

    if (position ==1):
        return [1]

    if (position == 2):
        return [1,1]

    next_series = lambda series, _: series + [series [-1] + series [-2]]
    return reduce(next_series, range(position - 2), [1, 1])

I can't figure out what the equivalent of reduce in Scala is. This is what I currently have. Everything works fine except the last line.

def immutable_fibonacci(position: Int) : ArrayBuffer[Int] = {

    if (position == 1){
          return ArrayBuffer(1)
     }

     if (position == 2){
         return ArrayBuffer(1,1)
     }

     var next_series = (series: ArrayBuffer[Int]) => series :+ ( series( series.size - 1) + series( series.size -2))

     return reduce(next_series, 2 to position, ArrayBuffer(1,1))
}

Answer 1

Summary of Python reduce , for reference:

reduce(function, iterable[, initializer])

Traversable

A good type to look at is Traversable , a supertype of ArrayBuffer . You may want to just peruse that API for a while, because there's a lot of useful stuff in there.

Reduce

The equivalent of Python's reduce , when the initializer arg is omitted, is Scala's Traversable[A]#reduceLeft :

reduceLeft[B >: A](op: (B, A) => B): B

The iterable arg from the Python function corresponds to the Traversable instance, and the function arg from the Python function corresponds to op .

Note that there are also methods named reduce , reduceRight , reduceLeftOption , and reduceRightOption , which are similar but slightly different.

Fold

Your example, which does provide an initializer arg, corresponds to Scala's Traversable[A]#foldLeft :

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

The initializer arg from the Python function corresponds to the z arg in foldLeft .

Again, note that there are some related methods named fold and foldRight .

Fibonacci

Without changing the algorithm, here's a cleaned-up version of your code:

def fibonacci(position: Int): Seq[Int] =
  position match {
    case 1 => Vector(1)
    case 2 => Vector(1, 1)
    case _ =>
      (2 to position).foldLeft(Vector(1, 1)) { (series, _) =>
        series :+ (series(series.size - 1) + series(series.size - 2))
      }
  }

A few miscellaneous notes:

• We generally never use the return keyword
• Pattern matching (what we're doing with the match keyword) is often considered cleaner than an if - else chain
• Replace var (which allows multiple assignment) with val (which doesn't) wherever possible
• Don't use a mutable collection ( ArrayBuffer ) if you don't need to. Vector is a good general-purpose immutable sequence.

And while we're on the topic of collections and the Fibonacci series, for fun you may want to check out the first example in the Stream documentation:

val fibs: Stream[BigInt] = BigInt(0) #:: BigInt(1) #::
  fibs.zip(fibs.tail).map { n => n._1 + n._2 }

fibs.drop(1).take(6).mkString(" ")
// "1 1 2 3 5 8"