tstone

@(place: Place)

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


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


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

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

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

// Given

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


// These are equivalent...

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

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

// 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

// bool.scala.html

@(param: Boolean)
<h1>Value: @param</h1>

// index.scala.html

@bool(Some(false))
@bool("false")

tstone

// -- Measuring ---

def time[A](label: String, count: Int = 100)(block: => A): Long = {
  // the first test run on the console is compiling it
  block

  // Take the average of <count> runs
  (1 to count).toSeq.map { i =>
    val t0 = System.nanoTime()
    block

tstone

implicit class StringOps(s: String) {
  
  val one = { println("one"); "one" }
  val two = { println("two"); "two" }
  lazy val three = { println("three"); "value" }

}

scala> "asdf".three
one