chapter 17

Author: tobyweston

src/main/scala/s4j/scala/chapter17/ContainsExample.scala

@@ -0,0 +1,60 @@
+package s4j.scala.chapter17
+
+object Contains extends App {
+
+  def containsNegativeNumbers(numbers: List[Int]): Boolean = {
+    var exists = false
+    for (number <- numbers)
+      if (number < 0)
+        exists = true
+    exists
+  }
+
+  def containsOddNumbers(numbers: List[Int]): Boolean = {
+    var exists = false
+    for (number <- numbers)
+      if (number % 2 == 1)
+        exists = true
+    exists
+  }
+
+  def contains(numbers: List[Int], predicate: Int => Boolean): Boolean = {
+    var exists = false
+    for (number <- numbers)
+      if (predicate(number))
+        exists = true
+    exists
+  }
+
+ def contains2(numbers: List[Int])(predicate: Int => Boolean): Boolean = {
+    var exists = false
+    for (number <- numbers)
+      if (predicate(number))
+        exists = true
+    exists
+  }
+
+
+  println(containsNegativeNumbers(List(0, 1, -1, 45)))
+  println(containsNegativeNumbers(List(0, 1, 9, 45)))
+  println(containsOddNumbers(List(0, 1, -1, 45)))
+  println(containsOddNumbers(List(0, 2, 4, 10)))
+
+  // using higher order function
+  val negativeNumbers = (x: Int) => x < 0
+  println(contains(List(0, 1, -1, 45), negativeNumbers))
+  println(contains(List(0, 1, 9, 45), negativeNumbers))
+
+  val oddNumbers = (x: Int) => x % 2 == 1
+  println(contains(List(0, 1, -1, 45), oddNumbers))
+  println(contains(List(0, 2, 4, 10), oddNumbers))
+
+  println
+  println(contains2(List(0, 1, -1, 45)) {
+    _ < 0
+  })
+  println(contains2(List(0, 1, -1, 45)) {
+    _ % 2 == 1
+  })
+
+}

src/main/scala/s4j/scala/chapter17/Curry.scala

@@ -0,0 +1,14 @@
+package s4j.scala.chapter17
+
+object Curry extends App {
+
+  val a = "a"
+  val b = "b"
+
+  def f(a: String)(b: String): String = a + b
+
+  val f2: (String) => String = f(a)
+  val result: String = f2(b)
+
+  val r: String = f(a)(b)
+}

src/main/scala/s4j/scala/chapter17/Numerals.scala

@@ -0,0 +1,17 @@
+package s4j.scala.chapter17
+
+object Numerals extends App {
+
+  val numerals = List("I", "II", "III", "IV", "V", "VI", "VII")
+
+  private val function = (value: String) => println(value)
+
+  numerals.foreach((value: String) => function(value)) // long hand
+  numerals.foreach(function(_))                        // implicit parameter
+  numerals.foreach(function)                           // method value
+
+  numerals.foreach((value: String) => println(value)) // long hand
+  numerals.foreach(println(_))                        // implicit parameter
+  numerals.foreach(println)                           // method value
+
+}

src/main/scala/s4j/scala/chapter17/ThreadExample.scala

@@ -0,0 +1,122 @@
+package s4j.scala.chapter17
+
+import s4j.scala.chapter12.{Customer, ShoppingBasket}
+import s4j.scala.chapter17.ThreadExample._
+
+object ThreadExample {
+
+  def runInThread(function: () => Unit) {
+    new Thread() {
+      override def run(): Unit = function() // aka function.apply()
+    }.start()
+  }
+
+  def runInThread2(function: => Unit) {     // call-by-name
+    new Thread() {
+      override def run(): Unit = function   // not function()
+    }.start()
+  }
+
+  def runInThread3(group: String, function: => Unit) {
+    new Thread(new ThreadGroup(group), () => function).start()
+  }
+
+  def runInThread4(group: String)(function: => Unit) {
+    new Thread(new ThreadGroup(group), () => function).start()
+  }
+
+  def main(args: Array[String]) {
+    runInThread(() => {
+      // some long running task
+      println("Hello function")
+    })
+
+    runInThread2 {
+      println("Hello Lazy val")
+    }
+  }
+}
+
+/*
+ a class representing some kind of UI with 'update' methods
+ to update itself
+*/
+class UI {
+
+  def updateUiElements() {
+    new Thread() {
+      override def run(): Unit = updateCustomerBasket(basket)
+    }.start()
+
+    new Thread() {
+      override def run(): Unit = updateOffersFor(customer)
+    }.start()
+
+    // more updates, all done in their own threads
+  }
+
+  def updateUiElements2() {
+    runInThread(() => updateCustomerBasket(basket))
+    runInThread(() => updateOffersFor(customer))
+    // more updates, all done in their own threads
+  }
+
+  def updateUiElements3() {
+    runInThread { () =>
+      updateCustomerBasket(basket)
+    }
+    runInThread { () =>
+      updateOffersFor(customer)
+    }
+    // more updates, all done in their own threads
+  }
+
+  def updateUiElementsX() {
+    runInThread(() => {
+      applyDiscountToBasket(basket)
+      updateCustomerBasket(basket)
+    })
+    runInThread(() => updateOffersFor(customer))
+    // more updates, all done in their own threads
+  }
+
+  def updateUiElements4() {
+    runInThread2 {
+      applyDiscountToBasket(basket)
+      updateCustomerBasket(basket)
+    }
+    runInThread2 {
+      updateOffersFor(customer)
+    }
+    // more updates, all done in their own threads
+  }
+
+  def updateUiElements5() {
+    runInThread3("basket", {
+      applyDiscountToBasket(basket)
+      updateCustomerBasket(basket)
+    })
+    runInThread3("customer",
+      updateOffersFor(customer)
+    )
+    // more updates, all done in their own threads
+  }
+
+  def updateUiElements6() {
+    runInThread4("basket") {
+      applyDiscountToBasket(basket)
+      updateCustomerBasket(basket)
+    }
+    runInThread3("customer",
+      updateOffersFor(customer)
+    )
+    // more updates, all done in their own threads
+  }
+
+  def applyDiscountToBasket(basket: ShoppingBasket) {}
+  def updateCustomerBasket(basket: ShoppingBasket) {}
+  def updateOffersFor(customer: Customer) {}
+
+  private val basket = new ShoppingBasket()
+  private val customer = new Customer("", "")
+}

src/main/scala/s4j/scala/chapter17/Timer.scala

@@ -0,0 +1,59 @@
+package s4j.scala.chapter17
+
+import java.util.Date
+
+object TimerExample {
+  
+  def exampleTimer() = {
+    val timer = new NaiveTimer()
+    timer.start()
+    someLongRunningTask()
+    val time = timer.stop()
+    println("process took " + time + "ms")
+  }
+
+  def anotherExampleTimer() = {
+    val timer = Timer()
+    timer.time {
+      someLongRunningTask()
+      null
+    }
+    println("process took " + timer + "ms")
+  }
+
+  def yetAnotherExampleTimer() = {
+    val timer = Timer()
+    timer.time(() => {
+      someLongRunningTask()
+    })
+    println("process took " + timer + "ms")
+  }
+
+  def someLongRunningTask() = Thread.sleep(1000)
+}
+
+class NaiveTimer {
+  private var startDate: Date = null
+
+  def start() = startDate = new Date
+
+  def stop(): Long = new Date().getTime - startDate.getTime
+}
+
+object Timer {
+  def apply() = new Timer()
+}
+
+class Timer {
+
+  private val start = new Date
+
+  def time(function: () => Unit) {
+    try {
+      function.apply()
+    } finally {
+      new Date().getTime - start.getTime
+    }
+  }
+  
+}