chapter20 + 21

Author: tobyweston

src/main/scala/s4j/scala/chapter20/Address.scala

@@ -0,0 +1,3 @@
+package s4j.scala.chapter20
+
+case class Address(street: String, postcode: Option[String])

src/main/scala/s4j/scala/chapter20/Customer.scala

@@ -0,0 +1,22 @@
+package s4j.scala.chapter20
+
+case class Customer(name: String, address: Option[Address]) extends Ordered[Customer] {
+  private final val basket: ShoppingBasket = new ShoppingBasket
+
+  def add(item: Item) {
+    basket.add(item)
+  }
+
+  def total: Double = {
+    basket.value
+  }
+
+  override def compare(that: Customer): Int = name.compare(that.name)
+  override def toString: String = name + " $ " + total
+}
+
+//object Customer {
+//  def unapply(customer: Customer): Option[(String, Option[Address])] = {
+//    if (customer == null) None else Some(customer.name, customer.address)
+//  }
+//}

src/main/scala/s4j/scala/chapter20/CustomerSet.scala

@@ -0,0 +1,38 @@
+package s4j.scala.chapter20
+
+import scala.collection.mutable
+
+class CustomerSet extends Customers {
+
+  private val customers = mutable.Set[Customer]()
+
+  def add(customer: Customer) = customers.add(customer)
+
+  def find(name: String): Option[Customer] = {
+    for (customer <- customers) {
+      if (customer.name == name)
+        return Some(customer)
+    }
+    None
+  }
+
+  def findOrNull(name: String): Customer = {
+    for (customer <- customers) {
+      if (customer.name == name)
+        return customer
+    }
+    null
+  }
+
+  def findOrThrow(name: String): Customer = {
+    for (customer <- customers) {
+      if (customer.name == name)
+        return customer
+    }
+    throw new NotFoundException(name)
+  }
+
+  def iterator: Iterator[Customer] = customers.iterator
+}
+
+class NotFoundException(name: String) extends Exception(name)

src/main/scala/s4j/scala/chapter20/Customers.scala

@@ -0,0 +1,11 @@
+package s4j.scala.chapter20
+
+trait Customers extends Iterable[Customer] {
+  def add(Customer: Customer)
+  def find(name: String): Option[Customer]
+  def findOrNull(name: String): Customer
+}
+
+object Customers {
+  def apply() = new CustomerSet()
+}

src/main/scala/s4j/scala/chapter20/Example.scala

@@ -0,0 +1,75 @@
+package s4j.scala.chapter20
+
+import s4j.scala.chapter20.CustomerDatabase.database
+
+object CustomerDatabase {
+  val database = Customers()
+
+  val customerA = Customer("Albert", Some(Address("1a Bridge St", None)))
+  val customerB = Customer("Beatriz", None)
+  val customerC = Customer("Carol", Some(Address("2a Finsbury Circus", Some("AL1 2PY"))))
+  val customerD = Customer("Sherlock", Some(Address("21b Baker Street", Some("NW1 6XE"))))
+
+  customerA.add(PricedItem(10))
+  customerA.add(PricedItem(5))
+  customerC.add(PricedItem(10))
+
+  database.add(customerA)
+  database.add(customerB)
+  database.add(customerC)
+  database.add(customerD)
+}
+
+object Example extends App {
+
+  // null case
+  val albert = database.findOrNull("Albert")
+  val basket = if (albert != null) albert.total else 0D
+
+  // map over option
+  val exists = database.find("Albert").map(customer => "customer exists")
+  val basketValue = database.find("Albert").map(customer => customer.total).getOrElse(0D) // forced to handle the else? get would throw
+
+
+  val customers = Set("Albert", "Beatriz", "Carol", "Dave", "Erin", "Sherlock")
+
+  def sumCustomerBaskets_NulLCheckVersion() = {
+    // all.map(customers.findOrNull).map(_.total).sum // throws NPE
+    // or
+    customers.map(database.findOrNull).map(customer => if (customer != null) customer.total else 0D).sum
+  }
+
+  def sumCustomerBaskets_NulLAvoidingPatternMatch() = {
+    customers.map(database.findOrNull(_) match {
+      case customer@Customer(_, _) => customer.total // why no if customer != null clause? it matches on null below
+      case a @ _                   => println(a); 0D
+    }).sum
+  }
+
+  def sumCustomerBaskets_MapCouldThrowAnException() = {
+    // all.map(customers.find(_)).map(customer => customer.get.total) // could throw an exception
+    // customers.find("Missing").map(customer => customer.total).get  // throws an exception
+    database.find("Missing") match {
+      case Some(customer) => customer.total
+      case None           => 0D
+    }
+  }
+
+  def sumCustomerBaskets_MapThenFlattenVersion() = {
+    customers.map(database.find(_).map(_.total)).flatten.sum
+  }
+
+  def sumCustomerBaskets_FlatMapVersion() = {
+    customers.flatMap(name => database.find(name)).map(customer => customer.total).sum
+  }
+
+
+  val partial: Set[Option[Customer]] = customers.map(database.find)
+
+  println("1. " + sumCustomerBaskets_NulLCheckVersion())
+  println("2. " + sumCustomerBaskets_NulLAvoidingPatternMatch()) // yuk!
+  println("3. " + sumCustomerBaskets_MapCouldThrowAnException())
+  println("4. " + sumCustomerBaskets_MapThenFlattenVersion())
+  println("5. " + sumCustomerBaskets_FlatMapVersion())
+
+}

src/main/scala/s4j/scala/chapter20/Item.scala

@@ -0,0 +1,5 @@
+package s4j.scala.chapter20
+
+trait Item {
+  def price: Double
+}

src/main/scala/s4j/scala/chapter20/PricedItem.scala

@@ -0,0 +1,3 @@
+package s4j.scala.chapter20
+
+case class PricedItem(price: Double) extends Item

src/main/scala/s4j/scala/chapter20/ShoppingBasket.scala

@@ -0,0 +1,16 @@
+package s4j.scala.chapter20
+
+import scala.collection.mutable
+
+class ShoppingBasket {
+  private val basket = mutable.HashSet[Item]()
+
+  def add(items: Item*) {
+    for (item <- items)
+      basket.add(item)
+  }
+
+  def value: Double = {
+    basket.map(_.price).sum
+  }
+}

src/main/scala/s4j/scala/chapter21/Address.scala

@@ -0,0 +1,3 @@
+package s4j.scala.chapter21
+
+case class Address(street: String, postcode: Option[String])

src/main/scala/s4j/scala/chapter21/Customer.scala

@@ -0,0 +1,22 @@
+package s4j.scala.chapter21
+
+case class Customer(name: String, address: Option[Address]) extends Ordered[Customer] {
+  private final val basket: ShoppingBasket = new ShoppingBasket
+
+  def add(item: Item) {
+    basket.add(item)
+  }
+
+  def total: Double = {
+    basket.value
+  }
+
+  override def compare(that: Customer): Int = name.compare(that.name)
+  override def toString: String = name + " $ " + total
+}
+
+//object Customer {
+//  def unapply(customer: Customer): Option[(String, Option[Address])] = {
+//    if (customer == null) None else Some(customer.name, customer.address)
+//  }
+//}