Functions and Methods

Helper Composition

Use two pure helpers in one expression.

helper-composition Small pure helpers can be composed by passing one helper's result into the next.

Helper Composition

start
HelperComposition.scala
Replay: real traced execution (multi-file project)
object Main {
  def double(value: Int): Int = {
    value * 2
  }

  def addOne(value: Int): Int = {
    value + 1
  }

  def main(args: Array[String]): Unit = {
    val start = 3
    val result = addOne(double(start))

    println("start=" + start)
    println("result=" + result)
  }
}

object Main {
  def double(value: Int): Int = {
    value * 2
  }

  def addOne(value: Int): Int = {
    value + 1
  }

  def main(args: Array[String]): Unit = {
    val start = 4
    val result = addOne(double(start))

    println("start=" + start)
    println("result=" + result)
  }
}

object Main {
  def double(value: Int): Int = {
    value * 2
  }

  def addOne(value: Int): Int = {
    value + 1
  }

  def main(args: Array[String]): Unit = {
    val start = 6
    val result = addOne(double(start))

    println("start=" + start)
    println("result=" + result)
  }
}

  1. start ← 3

    10def main(args: Array[String]): Unit = {11  val start→ 3 = 3 //@start=4, 612  val result = addOne(double(start3))1314  println("start=" + start)

  2. def double(value: Int): Int =

    1object Main {2  def double(value3: Int): Int = {3    value3 * 24  }

  3. def addOne(value: Int): Int =

    6def addOne(value6: Int): Int = {7  value6 + 18}

  4. result ← 7

    11    val start = 3 //@start=4, 612    val result→ 7 = addOne(double(start3))1314    println("start=" + start3)15    println("result=" + result7)16  }17}
    outputstart=3
result=7

  1. start ← 4

    10def main(args: Array[String]): Unit = {11  val start→ 4 = 412  val result = addOne(double(start4))1314  println("start=" + start)

  2. def double(value: Int): Int =

    1object Main {2  def double(value4: Int): Int = {3    value4 * 24  }

  3. def addOne(value: Int): Int =

    6def addOne(value8: Int): Int = {7  value8 + 18}

  4. result ← 9

    11    val start = 412    val result→ 9 = addOne(double(start4))1314    println("start=" + start4)15    println("result=" + result9)16  }17}
    outputstart=4
result=9

  1. start ← 6

    10def main(args: Array[String]): Unit = {11  val start→ 6 = 612  val result = addOne(double(start6))1314  println("start=" + start)

  2. def double(value: Int): Int =

    1object Main {2  def double(value6: Int): Int = {3    value6 * 24  }

  3. def addOne(value: Int): Int =

    6def addOne(value12: Int): Int = {7  value12 + 18}

  4. result ← 13

    11    val start = 612    val result→ 13 = addOne(double(start6))1314    println("start=" + start6)15    println("result=" + result13)16  }17}
    outputstart=6
result=13

Follow the Helpers

  1. start starts as 3.
  2. double(start) runs first and returns 6.
  3. addOne(6) runs next.
  4. addOne returns 7.
  5. The caller stores that value in result. | start | after double | after addOne | | --- | --- | --- | | 3 | 6 | 7 | | 4 | 8 | 9 | | 6 | 12 | 13 |

Exercise: HelperComposition.scala

Reproduce start=3 and result=7, then use the pinned start variants 4 and 6 to predict result=9 and result=13.