Scala Equality in 30 seconds

1. In scala == delegages to equals method.

 a == b is equivalent to a equals b
2. If you want to check referrential equality you call eq method. 

 a eq b is true only if a and b are referrences to the same object

3. Case classes and Value Classes (2.10) get the equals and hashcode based on class parameters for free.

End of the story!

The simplest dynamically typed json parsing with Dynamic in Scala 2.10

I love the way dynamically typed languages handle json or xml parsing. With Scala 2.10 we can do it using Dynamic trait. Here is a first draft.
Please feel free to copy/paste/reuse at your own risk.

	import util.parsing.json.JSON
	import io.Source
	import scala.language.dynamics
	object Example extends App{
	val json = """{
	"name" : "Adam Slodowy",
	"active": "true",
	"roles" : [ "teacher", "admin" ],
	"lessons" : [ { "id": 1 }, { "id": 2 } ],
	"security" : { "id" : 123, "login": "adams" }
	}"""
	val adam = JsonElement.parse(json).get
	case class Lesson(teacher: String, id: Int, name: String, active : Boolean = true)
	val lesson = Lesson(adam.name, adam.lessons.at(1).id, adam.lessons.at(1).name, adam.active)
	// will create Lesson("Adam Slodowy", 2, "", true ) - see the implicit conversions
	}
	trait JsonElement extends Dynamic{ self =>
	def selectDynamic(field: String) : JsonElement = EmptyElement
	def applyDynamic(field: String)(i: Int) : JsonElement = EmptyElement
	def toList : List[String] = sys.error(s"$this is not a list.")
	def asString: String = sys.error(s"$this has no string representation.")
	def length$ : Int = sys.error(s"$this has no length")
	}
	object JsonElement{
	def ^(s: String) = {
	require(!s.isEmpty, "Element is empty")
	s
	}
	implicit def toString(e: JsonElement) : String = e.asString
	implicit def toBoolean(e: JsonElement) : Boolean = (^(e.asString)).toBoolean
	implicit def toBigDecimal(e: JsonElement) : BigDecimal = BigDecimal(^(e.asString))
	implicit def toDouble(e: JsonElement) : Double = ^(e.asString).toDouble
	implicit def toFloat(e: JsonElement) : Float = ^(e.asString).toFloat
	implicit def toByte(e: JsonElement) : Byte = ^(e.asString).stripSuffix(".0").toByte
	implicit def toShort(e: JsonElement) : Short = ^(e.asString).stripSuffix(".0").toShort
	implicit def toInt(e: JsonElement) : Int = ^(e.asString).stripSuffix(".0").toInt
	implicit def toLong(e: JsonElement) : Long = ^(e.asString).stripSuffix(".0").toLong
	implicit def toList(e: JsonElement) : List[String] = e.toList
	def parse(json: String) = JSON.parseFull(json) map (JsonElement(_))
	def apply(any : Any) : JsonElement = any match {
	case x : Seq[Any] => new ArrayElement(x)
	case x : Map[String, Any] => new ComplexElement(x)
	case x => new PrimitiveElement(x)
	}
	}
	case class PrimitiveElement(x: Any) extends JsonElement{
	override def asString = x.toString
	}
	case object EmptyElement extends JsonElement{
	override def asString = ""
	override def toList = Nil
	}
	case class ArrayElement(private val x: Seq[Any]) extends JsonElement{
	private lazy val elements = x.map((JsonElement(_))).toArray
	override def applyDynamic(field: String)(i: Int) : JsonElement = elements.lift(i).getOrElse(EmptyElement)
	override def toList : List[String] = elements map (_.asString) toList
	override def length$ : Int = elements.length
	}
	case class ComplexElement(private val fields : Map[String, Any]) extends JsonElement{
	override def selectDynamic(field: String) : JsonElement = fields.get(field) map(JsonElement(_)) getOrElse(EmptyElement)
	}

view raw Json.scala hosted with ❤ by GitHub

The simplest Async Scala Http Client working with 2.10

This client is not the most efficient or the most async but it works and I am using it for testing my apps. Please feel free to copy/paste/reuse at your own risk.

	import concurrent.{Await, ExecutionContext, Future}
	import java.net.{HttpURLConnection, URL}
	import io.Source
	import concurrent.duration.FiniteDuration
	case class HttpResponse(code : Int, body: String, headers: Map[String, List[String]])
	case class RequestBody(body: String, contentType: String = "text/plain")
	object RequestBody{
	implicit def toRB(json: String) = RequestBody(json, contentType = "application/json")
	}
	class Http(baseUrl : String, cookie: Option[String] = None)(implicit ec: ExecutionContext, encoding: String="UTF-8"){
	def setCookie(cookie: String) = {
	new Http(baseUrl, Some(cookie))
	}
	import collection.JavaConverters._
	def get(path : String ) : Future[HttpResponse] = doRequest("GET", path)
	def post(path : String, requestBody: RequestBody ) : Future[HttpResponse] = doRequest("POST", path, Option(requestBody))
	def put(path : String, requestBody: RequestBody ) : Future[HttpResponse] = doRequest("PUT", path, Option(requestBody))
	def delete(path : String ) : Future[HttpResponse] = doRequest("DELETE", path)
	def doRequest(method: String, path: String, requestBody: Option[RequestBody] = None): Future[HttpResponse] = Future {
	val con = new URL(baseUrl + path).openConnection().asInstanceOf[HttpURLConnection]
	try {
	con.setDoInput(true)
	con.setInstanceFollowRedirects(false)
	cookie.foreach(cookie => con.setRequestProperty("Cookie", cookie))
	con.setRequestMethod(method)
	requestBody foreach{ requestBody=>
	con.setRequestProperty("Content-Type", s"${requestBody.contentType}; charset=$encoding")
	con.setDoOutput(true)
	val out = con.getOutputStream
	out.write(requestBody.body.getBytes(encoding))
	out.flush()
	out.close()
	}
	val headers = con.getHeaderFields.asScala.mapValues(_.asScala.toList).toMap - null
	val body = Source.fromInputStream(con.getInputStream).getLines() mkString ("\n")
	HttpResponse(con.getResponseCode, body, headers)
	} finally {
	con.disconnect()
	}
	}
	}

view raw Http.scala hosted with ❤ by GitHub

Akka-Camel 2.1 consumer/producer example.

	import akka.camel.{Consumer, CamelMessage}
	import akka.actor.{Props, ActorSystem}
	import akka.util.Timeout
	import akka.util.duration._
	import akka.pattern.ask
	import scaladays2012.{Email, EmailerConfig, Emailer}
	class HttpConsumerExample extends Consumer{
	def endpointUri = "jetty://http://0.0.0.0:1111/demo"
	implicit val timeout = Timeout(30 seconds)
	val emailer = context.actorOf(Props(new Emailer(EmailerConfig(System.getProperty("gmail.password")))), "Emailer")
	protected def receive = {
	case msg : CamelMessage => {
	val name = msg.header("name").getOrElse("Stranger")
	val message = "Hello %s from ScalaDays 2012!" format name
	sender ! message
	for( email <- msg header "email" ) {
	emailer ? Email("piotrga@gmail.com", email.toString, message, "hello") // ignoring the response
	}
	}
	}
	}
	import akka.actor.Actor
	import akka.camel.{Failure, CamelMessage, Producer}
	case class EmailerConfig(gmailPassword: Required[String])
	case class Email(from: String, to: String, subject: String, body: String)
	class Emailer(cfg: EmailerConfig) extends Actor with Producer{
	def endpointUri = "smtps://smtp.gmail.com:465?username=peter@scala-experts.com&password=%s&debugMode=false&defaultEncoding=utf-8" format cfg.gmailPassword.value
	override protected def transformOutgoingMessage(msg: Any) = msg match {
	case Email(from, to, subject, body) =>
	new CamelMessage(body, Map("from" -> from, "to" -> to, "subject"-> subject))
	}
	override protected def transformResponse(msg : Any) = msg match {
	case resp: Failure => akka.actor.Status.Failure(resp.getCause)
	case _ => msg
	}
	}
	object HttpConsumerApp extends App {
	val sys = ActorSystem("test")
	sys.actorOf(Props[HttpConsumerExample], "HttpConsumer")
	sys.awaitTermination()
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Atomic update of AtomicReference

Problem

I like the AtomicReference class. When used with a immutable class, it offers quite a nice and efficient abstraction for concurrent data structure. One thing it is missing, in my opinion, is the atomic update method, ie.

  val list = new AtomicReference(List(1,2,3))
  list.update(list => list.map(_ *2))

Solution

You just need to import the Atomic class, and it will pimp the AtomicReference, so you can call the update method. See below:

	import annotation.tailrec
	import java.util.concurrent.atomic.AtomicReference
	object Atomic {
	def apply[T]( obj : T) = new Atomic(new AtomicReference(obj))
	implicit def toAtomic[T]( ref : AtomicReference[T]) : Atomic[T] = new Atomic(ref)
	}
	class Atomic[T](val atomic : AtomicReference[T]) {
	@tailrec
	final def update(f: T => T) : T = {
	val oldValue = atomic.get()
	val newValue = f(oldValue)
	if (atomic.compareAndSet(oldValue, newValue)) newValue else update(f)
	}
	def get() = atomic.get()
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Enjoy!

Managing of opening and closing multiple resources automatically in Scala

Problem

Managing opening and closing multiple resource automatically. For example when you want to copy a file you need to open and close both input and output files.

Solution

I recently came across scala-arm library written by Josh Suereth. I liked the idea so much that I wanted to experiment with writing something similar, but a bit simpler myself.

Here is what I came up with:

	import io.Source
	import java.io.FileWriter
	object ManagedDemo extends App{
	import Managed._
	import Managed.{managed => ®}
	for (
	fw <- ®(new FileWriter("target/test-out.txt"));
	fr <- ®(Source.fromFile("build.sbt"))
	){
	fw.write(fr.mkString)
	}
	println("written:\n"+ ®(Source.fromFile("target/test-out.txt")).map(_.mkString))
	}
	trait Managed{
	def close() : Unit
	}
	object Managed{
	implicit def close2Managed[A <: { def close() : Any }](c:A) : Managed = Managed( c.close() )
	implicit def dispose2Managed[A <: { def dispose() : Any }](c:A) : Managed = Managed( c.dispose() )
	private def apply(closeResource : => Unit) : Managed = new Managed {
	def close() : Unit = closeResource
	}
	def managed[A <% Managed](res: => A) = new Traversable[A]{
	def foreach[U](f: (A) => U) {
	val closable : A = res
	try{
	f(closable)
	}finally{
	closable.close()
	}
	}
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Explanation

The magic is in the foreach method and the way the for and map work. They both use the foreach method. We are using this fact and wrapping the iteration with try-finally block, so we can call the close or dispose method when the traversal is finished.

The rest of the magic are just implicit conversions between anything which contains def close() : Any or def dispose() : Any and Managed trait.

Enjoy!

Stop your services gracefully in Scala with tryAll

	object ErrorUtils{
	/**
	* Executes a block and returns the result wrapped by Right class, or exception wrapped by Left class.
	*/
	def either[T](block:() => T) : Either[Throwable,T] = try {Right(block())} catch {case e => Left(e)}
	/**
	* Executes all blocks in order and collects exceptions. It guarantees to execute all blocks, even if some of them fail.
	* It throws a BlockException, if any number of blocks fail. BlockException contains a list of thrown exceptions.
	*
	* <br/><br/>Example:
	<pre>
	tryAll(
	service1.stop,
	service2.shutdown,
	service3.kill
	)
	</pre>
	*
	* @return nothing
	* @throws BlockException if any number of blocks fail. BlockException contains a list of thrown exceptions.
	*
	*/
	def tryAll(block1 : => Unit, block2 : => Unit = {}, block3 : => Unit= {}, block4 : => Unit = {}, block5 : => Unit = {}, block6 : => Unit = {}) = {
	val blocks = List(()=>block1, ()=>block2, ()=>block3, ()=>block4, ()=>block5, ()=>block6)
	val errors = blocks.toList.map(either(_)).filter(_.isLeft).map{case Left(e) => e}
	if (!errors.isEmpty) throw new BlockException(errors)
	}
	case class BlockException(errors : List[Throwable]) extends RuntimeException("There were errors while executing blocks: "+errors)
	}

view raw gistfile1.scala hosted with ❤ by GitHub