casualjim

class A {
  def a = "a"
  val aa = "aa"
}

object B { this: A =>

  def b = "b"
  val bb = "bb"
}

casualjim

scala> trait A {
     | private val a = "a"
     | private lazy val b = "b"
     | private def c = "c"
     | private var d = "d"
     | }
defined trait A

scala> abstract class B {
     | val a = "aa"

casualjim

package org.scalatra
package akka

import _root_.akka.util.duration._
import java.util.concurrent.atomic.AtomicBoolean
import javax.servlet.{ AsyncContext, AsyncEvent, AsyncListener }
import javax.servlet.http.{ HttpServletResponse, HttpServletRequest }
import _root_.akka.dispatch.{ Await, Future }
import _root_.akka.actor.{ Actor, ActorSystem }

casualjim

package com.matygo.controllers
import java.io.File
import java.io.PrintWriter
import java.io.StringWriter
import scala.collection.JavaConversions.mapAsScalaMap
import org.scalatra.ScalatraKernel.MultiParamsKey
import org.scalatra.ContentTypeInferrer
import org.scalatra.util.MultiMap
import org.scalatra.CookieSupport
import org.scalatra.RouteMatcher

casualjim

trait CookieSupport extends Handler {
  self: ScalatraKernel =>

  import CookieSupport._

  private val _cookieOptions = new DynamicVariable[CookieOptions](null)
  implicit def cookieOptions: CookieOptions = _cookieOptions.value

  private val _cookies = new DynamicVariable[SweetCookies](null)
  def cookies = _cookies.value

casualjim

scala> class Blah extends DelayedInit {
     | def delayedInit(init: => Unit) {
     | println("before init")
     | init
     | println("after init")
     | }
     | println("init")
     | }
defined class Blah

casualjim

2012-01-03 10:53:23
Full thread dump Java HotSpot(TM) 64-Bit Server VM (20.4-b02-402 mixed mode):

"default-dispatcher25" prio=5 tid=7f86753af800 nid=0x162845000 waiting on condition [162844000]
   java.lang.Thread.State: TIMED_WAITING (parking)
	at sun.misc.Unsafe.park(Native Method)
	- parking to wait for  <7b5fc17d0> (a java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject)
	at java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:196)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2025)

casualjim

package testing

import akka.actor._

object Main {

  def main(args: Array[String]) {  

    val sys1 = ActorSystem("first")
    val sys2 = ActorSystem("second")

casualjim

package mojolly.testing

import org.specs2.specification._
import akka.actor._
import akka.testkit.TestKit

trait AkkaContext extends After {
  val testkit = new TestKit(ActorSystem(newUuid().toString))
  implicit def system = testkit.system

casualjim

scala> def test(a: Any) = a match {
     | case _ : Unit => "Unit"
     | case _ => "Other"
     | }
test: (a: Any)java.lang.String

scala> test(())
res1: java.lang.String = Unit

scala> test(println("hello"))