tstone

// Function "add" implemented in javascript
 
function add(x, y) {
  return x + y;
}
 
// Function "add" implemented in Scala as javascript is actually implementing it behind the scenes
 
sealed abstract class DynamicType
 

tstone

class A
class B extends A
class C extends B

val a = new A
val b = new B
val c = new C

def f[T : ClassTag](a: A) = a match {
  case _: T => "is given type"

tstone

scala> import mq.models.place._
import mq.models.place._

scala> import mq.models._
import mq.models._

scala> val a = Airport(123, "slug", Address("US"), LatLng(1,-1), PlaceAttributes(), PoiAttributes(), AirportAttributes())
a: mq.models.place.Airport = Airport(123,slug,Address(US,None,None,None,None,None),LatLng(1.0,-1.0),PlaceAttributes(None,List(),None),PoiAttributes(None,None,None,None,None,List(),List(),None,None,None,List(),List(),List(),List(),None,List()),AirportAttributes(,List(),None))

scala> a.name(Some("foo"))

tstone

// Given

trait Common
class A extends Common
class B extends Common
class C extends Common


// These are equivalent...

tstone

scala> class A { val prop = "a" }
scala> class B extends A { override val prop = "b" }
scala> class C extends B
scala> implicit class Foo(a: A) { def value = a.prop }
scala> implicit class Bar(b: B) { def value = b.prop }
scala> val c = new C
scala> c.value
res0: String = b

tstone

// DEMO CODE

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

def time[A](label: String, block: => Future[A]) = {
  val t0 = System.nanoTime()
  block.onComplete {
    case _ => {
      val t1 = System.nanoTime()

tstone

@(place: Place)

<a href="@place.details.contact.website">Website</a>


------------------------------------------------------------------------


<a href="{{website}}">Website</a>

tstone

// Class
package presenters.poiattributes

import scala.language.implicitConversions
import play.api.templates.Html


trait AttributePresenter {
  val identifier: String
  val value: Any

tstone

  
  implicit class Unlessable[A](a: => A) {
    def unless(p: => Boolean) = if (!p) Some(a) else None
  }

  implicit class Iffable[A](a: => A) {
    def iff(p: => Boolean) = if (p) Some(a) else None
  } 
  

tstone

// reporting library
// http://stackoverflow.com/questions/9160001/how-to-profile-methods-in-scala

def perf[R](block: => R): Unit = {
  val t0 = System.nanoTime()
  block
  val t1 = System.nanoTime()

  val elapsed = (t1 - t0) / 1000000000f
  println("Elapsed time: " + elapsed + "s")