Scala Higher Order Function Little Confused


I was running the below Scala code in Worksheet:

import scala.math.abs
import scala.annotation.tailrec

object FixedPoint {
  println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet

  val tolerance = 0.0001                          //> tolerance  : Double = 1.0E-4
  def isCloseEnough(x: Double, y: Double): Boolean = {
    abs((x - y) / x) / x < tolerance
  }                                               //> isCloseEnough: (x: Double, y: Double)Boolean
  def fixedPoint(f: Double => Double)(firstGuess: Double): Double = {
    def iterate(guess: Double): Double = {
      val next = f(guess)
      if (isCloseEnough(guess, next)) next
      else iterate(next)
  }                                               //> fixedPoint: (f: Double => Double)(firstGuess: Double)Double

  def myFixedPoint = fixedPoint(x => 1 + x / 2)(1)//> myFixedPoint: => Double
  myFixedPoint                                    //> res0: Double = 1.999755859375

  def squareRoot(x: Double) = fixedPoint(y => (y + x / y) / 2)(1)
                                                  //> squareRoot: (x: Double)Double
  squareRoot(2)                                   //> res1: Double = 1.4142135623746899

  def calculateAverate(f: Double => Double)(x: Double) = (x + f(x)) / 2
                                                  //> calculateAverate: (f: Double => Double)(x: Double)Double
  def myNewSquareRoot(x: Double): Double = fixedPoint(calculateAverate(y => x / y))(1)
                                                  //> myNewSquareRoot: (x: Double)Double
  myNewSquareRoot(2)                              //> res2: Double = 1.4142135623746899

What is making me confused are:

  • Scala worksheet is showing below for my fixedPoint function

fixedPoint: (f: Double => Double)(firstGuess: Double)Double

What is this? Is this function type/ function definition or I am missing the term? Basically how I can explain this function in English?

  • Scala worksheet is showing below for my calculateAverate function

calculateAverate: (f: Double => Double)(x: Double)Double

But it looks to me the return type of my function is Double, but I was expecting Double => Double. The reason is I am going to use this with fixedPoint which expects Double => Double like below:

def myNewSquareRoot(x: Double): Double = fixedPoint(calculateAverate(y => x / y))(1)

Please help me to understand Higher Order Function / Currying more clearly. Thanks in advance.

The function

def fixedPoint (f: Double => Double)(firstGuess: Double):Double

is a function definition which takes two arguments:

  1. a function "f" which takes a parameter of type Double which returns a Double and
  2. a Double value named "firstGuess"

and returns a Double. The separation of the single parameters into their own parenthesis groups allows the function to be used in currying:

def mySqrtCalc(x:Double)(firstGuess:Double):Double = {...}

val mySqrtFunc = mySqrtCalc(2.0) _

val v = mySqrtFunc(1) // parameter firstGuess is set to 1

Beside the ability for currying, this is equivalent to the uncurried version

def fixedPoint (f: Double => Double,firstGuess: Double):Double

which might look more familiar to you.

The result of the calculateAverate is a Double because you add up the result of applying the passed function f to x with x which gives you a Double because f is a function Double => Double.

You use calculateAverate method in a curried way in your myNewSquareRoot method body, by giving only the first of both parameters in first place and omitting the second one, which is taken from the from the outer fixedPoint method. Omitting the second parameter of calculateAverate gives you a method Double=>Double as it is required by the fixedPoint method.

You might insert some println(s"<methodname> value=$value") to observe the execution flow and understand the method call order.