Daanyaal Syed did a nice experiment to determine how much memoizing helps.  Here is how his code (slightly modified) runs in a worksheet. You can see that the archive makes an enormous(!) difference. (fibArchive is defined inside the outer function to ensure that it starts with a fresh archive. Of course to make best use of an archive you don't want to do this but want to accumulate results from call to call.)

But using the helper function is even faster.

  def fibonacciWithArchiveOption(n: Int, useArchive: Boolean): Int = {

    var fibArchive = Map[Int, Int]() // Create a new archive

    def fibonacci(n: Int): Int = {
      if (useArchive && fibArchive.contains(n)) fibArchive(n)
      else {
        val value =
          if (n == 1 || n == 2) 1
          else fibonacci(n - 1) + fibonacci(n - 2)

        if (useArchive) fibArchive += n -> value
        value
      }
    }

    fibonacci(n)
  }                   //> fibonacciWithArchiveOption: (n: Int, useArchive: Boolean)Int

 

  // Do you get the same answers with and without the archive?  Yes.

  (1 to 5).map(fibonacciWithArchiveOption(_, false)) ==

  (1 to 5).map(fibonacciWithArchiveOption(_, true))
                     //> res0: Boolean = true

  def fibonacciWithHelper(n: Int): Int = {

    def fibonacciHelper(prevFib: Int, fibSoFar: Int, upTo: Int): Int = {
      if (upTo == n) fibSoFar
      else fibonacciHelper(fibSoFar, prevFib + fibSoFar, upTo + 1)
    }

    fibonacciHelper(0, 1, 1)
  }                                               //> fibonacciWithHelper: (n: Int)Int

     

  // Do you get the same answers recursively and with the helper?  Yes.

  (1 to 5).map(fibonacciWithArchiveOption(_, false)) ==

  (1 to 5).map(fibonacciWithHelper(_))

                     //> res1: Boolean = true

 

  // This function times the evaluation of its argument.

  def time[A](f: => A) = {
    val s = System.nanoTime
    val fun = f
    println("time: " + (System.nanoTime - s) / 1e6 + "ms")
  }                                               //> time: [A](f: => A)Unit

 

  // The time recursively without the archive.

  time { fibonacciWithArchiveOption(46, false) }  //> time: 11712.123557ms

  // The time recursively with the archive. (Much faster.)

  time { fibonacciWithArchiveOption(46, true) }   //> time: 0.765622ms

  // The time using the helper function. (Even faster.)

  time { fibonacciWithHelper(46) }                //> time: 0.023811ms

 

 

Would an archive help fibonacciWithHelper? If you think about it, the answer is that it would not because fibonacciWithHelper never makes a call to a possibly pre-computed fibonacci number. One could modify fibonacciWithHelper so that it could make use of an archive, but doing so would be a bit of work.The job would be to check the archive to see if the desired number has already been computed. If not, see what the largest number in the archive is and start the helper function from there rather than from 1. Also, fibonacciWithHelper should insert every fibonacci number it computes into the archive. That's the first thing the internal fibonacciHelper function should do. (If anyone takes this on, please post your code.)