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 {
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. | |
*/ |
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) |
val streets = for { a <- angiesStreet; b <- jacksStreet } yield (angiesStreet + " --- " + jacksStreet) // <--- None, becuase Jack's got no address | |
println(streets) |
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) |
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)) << |
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]) |
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()) |
// 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, |
// | |
// 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) |