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