petrovg

More on Scala Options

I came across this function today:

def validateTaskIdOpt(idOpt: Option[TaskId], dao: DAO): Try[Unit] = {
  val opt: Option[Try[Job]] = idOpt.map { id => CommonValidations.validateJobWithTaskId(id, dao) }

opt match {

petrovg

import java.io.PrintWriter
import java.util.Properties

import org.apache.spark.SparkContext
import org.apache.spark.scheduler._
import org.apache.spark.storage.RDDInfo

/**
  * Created by petrovg on 22/04/2017.
  */

petrovg

object TMP extends App {

  // A few things I wish were more obvious about Scala's Options

  case class CarMake(name: String)
  case class CarModel(name: String)

  case class Car(make: CarMake, model: Option[CarModel])

  case class StreetName(value: String)

petrovg

  val streets = for { a <- angiesStreet; b <- jacksStreet } yield (angiesStreet + " --- " + jacksStreet) // <--- None, becuase Jack's got no address
  println(streets)

petrovg

 val angiesStreet = angie.address.map(_.street) //  == StreetName("Three Elms Street")

println(jacksStreet)
println(angiesStreet)

// Many other collection functions produce predictable results:
println(angie.car.size)

println(angie.car.isEmpty)

petrovg

val jack = Person("Jack", address = None, car = None)
  val mary = Person("Mary", Some(Address("6A", StreetName("Mill Street"))), Some(Car(CarMake("VW"), Some(CarModel("Transporter")))))
  val angie = Person("Angie", address = Some(Address("22", StreetName("Three Elms Street"))), Some(Car(CarMake("VW"), Some(CarModel("Transporter")))))
  val laure = Person("Laure", address = None, car = Some(Car(CarMake("Peugeout"), None)))

  val people = List(jack, mary, angie, laure)

  jack.address.foreach(println)  //  <---  prints nothing

  mary.address.foreach(println)  //  <---  prints >> Address(6A,StreetName(Mill Street)) <<

petrovg

case class CarMake(name: String)
case class CarModel(name: String)
case class Car(make: CarMake, model: Option[CarModel])

case class StreetName(value: String)

case class Address(number: String, street: StreetName)

case class Person(name: String, address: Option[Address], car: Option[Car])

petrovg

class MapperHolder extends Serializable {
  lazy val mapper = {
    val m = new ObjectMapper with ScalaObjectMapper
    m.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
    m.registerModule(DefaultScalaModule)
    m
  }
}

val holderBcast = sc.broadcast(new MapperHolder())

petrovg

// Trying to understand the Magnet pattern (as used in spray)
// http://spray.io/blog/2012-12-13-the-magnet-pattern/

/**
 * A simple utility that writes things to strings.
 * We'd like it to be able to work for multiple different types
 */
object Writer {
  /**
   * We want this to work for multiple types that we don't know yet,

petrovg

//
//  Is there a better way to do this. The difficulty is coming from the fact that the
//  second future result may not be necessary, based on an optinal value in the first.
//
import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

case class User(name: String, homepageUrl: Option[String])
case class UserProfile(userName: String, profile: String)