Scala

When you're writing a "matching function", you do the following:

def someMatch(a: Int) = a match {
  case 42 => println("But what is the question?")
  case _ => println("WRONG!")
}

    someMatch(42)

What you don't do is this:

def someMatch(a: Int) = {
  a match {
    // ...
  }
}

Bad programmer!

It enables one to bind a matched pattern to a variable. Consider the following, for instance:

val o: Option[Int] = Some(2)
You can easily extract the content:

o match {
case Some(x) => println(x)
case None =>
}

But what if you wanted not the content of Some, but the option itself? That would be accomplished with this:

o match {
case x @ Some(_) => println(x)
case None =>
}

Note that @ can be used at any level, not just at the top level of the matching.

• Field annotated with @volatile are basically wrapped in a Mutex
• Thus, this field can only be accessed (read or write) by ONE thread at the time

• Ensures single thread ownership when being accessed

• All objects have this method by default

  • Except null-values, unlike @volatile which also works on null-values

  class Person(var name: String) {
    def set(changedName: String) {
      this.synchronized {
            name = changedName  // Only accessed by one thread at the time
      }
    }
  }
  

implicit means that the value will be taken from the context in which the function is called. If there is no implicit value of the right type in the scope, it will not compile.

class Prefixer(val prefix: String)
def addPrefix(s: String)(implicit p: Prefixer) = p.prefix + s

The above code is saying that the addPrefix method will only be valid as long as some variable named p of type Prefixer is to be found in the scope.

When the compiler finds an expression of the wrong type for the context, it will look for an implicit Function value of a type that will allow it to typecheck. So if an A is required and it finds a B, it will look for an implicit value of type B => A in scope.

implicit def doubleToInt(d: Double) = d.toInt
val x: Int = 42.0

// works the same as

def doubleToInt(d: Double) = d.toInt
val x: Int = doubleToInt(42.0)

In this example we can see that when the compiler finds a Double but expects an Int , it checks for a Function to do the conversion, finds it, and does the conversion, leading to the functions above being the same (if you had written them in two different shells/context of course..not in the same).

Messages are sent to an Actor through one of the following methods.

• ! means “fire-and-forget”, e.g. send a message asynchronously and return immediately. Also known as tell .
• ? sends a message asynchronously and returns a Future representing a possible reply. Also known as ask .

It is a good idea to provide factory methods on the companion object of each Actor which help keeping the creation of suitable Props as close to the actor definition as possible. This also avoids the pitfalls associated with using the Props.apply(...) method which takes a by-name argument, since within a companion object the given code block will not retain a reference to its enclosing scope:

object DemoActor {
  /**
    *  Create Props for an actor of this type.
    * 
    *  @param magicNumber The magic number to be passed to this actor’s constructor.
    *  @return a Props for creating this actor, which can then be further configured
    *          (e.g. calling `.withDispatcher()` on it)
    */
  def props(magicNumber: Int): Props = Props(new DemoActor(magicNumber))
}

class DemoActor(magicNumber: Int) extends Actor {
  def receive = {
    case x: Int => sender() ! (x + magicNumber)
  }
}

class SomeOtherActor extends Actor {
  // Props(new DemoActor(42)) would not be safe
  context.actorOf(DemoActor.props(42), "demo")
  // ...
}

• Configuartion class to specify options for the creation of actors
• Think of it as an immutable and thus freely shareable recipe for creating an actor including associated deployment information

ActorSystem is simply the top-most supervisor, which every other Actor is in some form "controlled" by.

The way to create an actor at this top-level is the following:

val system = ActorSystem("Name")
val actor = system.actorOf(Props[SomeActorClass])

• This is a great one: The Neophytes Guide To Scala, Part 14: Actor approach to concurreny.

See this issue on Github. Unfortunately, I haven't even located the scala class path yet o.O except for in the .ensime-cache directory in projects using sbt as a build-tool.