on 15-Aug-2014 (Fri)

Classes in Scala are static templates that can be instantiated into many objects at runtime.

the implicit return type Unit corresponds to void in Java-like languages

Since toString in user-defined class overrides the pre-defined toString method, it has to be tagged with the override flag.

values defined with the val construct are different from variables defined with the var construct (see class Point above) in that they do not allow updates; i.e. the value is constant

Here is an example for a class hierarchy which consists of an abstract super class Term and three concrete case classes Var, Fun, and App.

abstract class Term
case class Var(name: String) extends Term
case class Fun(arg: String, body: Term) extends Term
case class App(f: Term, v: Term) extends Term

To facilitate the construction of case class instances, Scala does not require that the new primitive is used. One can simply use the class name as a function.

Here is an example:

Fun("x", Fun("y", App(Var("x"), Var("y"))))

The constructor parameters of case classes are treated as public values and can be accessed directly.

val x = Var("x")
println(x.name)

For every case class the Scala compiler generates an equals method which implements structural equality and a toString method.

It makes only sense to define case classes if pattern matching is used to decompose data structures.

def printTerm(term: Term) {
term match { 
case Var(n) => print(n) 
case Fun(x, b) => print("^" + x + ".") printTerm(b) 
case App(f, v) => print("(") printTerm(f) print(" ") printTerm(v) print(")") 
}

pattern matching statement starting with the match keyword and consisting of sequences of case Pattern => Body clauses.

checks if a given term corresponds to a simple identity function

def isIdentityFun(term: Term): Boolean = term match { 
case Fun(x, Var(y)) if x == y => true 
case _ => false 
}

After matching a pattern with a given value, the guard (defined after the keyword if) is evaluated. If it returns true, the match succeeds; otherwise, it fails and the next pattern will be tried.

Sometimes it is necessary to express that the type of an object is a subtype of several other types. In Scala this can be expressed with the help of compound types, which are intersections of object types.

compound type is written like this in Scala: Cloneable with Resetable

def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
  //...
}

what the type of the parameter obj is. If it’s Cloneable then the object can be cloned, but not reset; if it’s Resetable we can reset it, but there is no clone operation. To avoid type casts in such a situation, we can specify the type of obj to be both Cloneable and Resetable. This compound type is written like this in Scala: Cloneable with Resetable.

Compound types can consist of several object types and they may have a single refinement which can be used to narrow the signature of existing object members. The general form is: A with B with C ... { refinement }

Comprehensions have the form for (enumerators) yield e, where enumerators refers to a semicolon-separated list of enumerators.

An enumerator is either a generator which introduces new variables, or it is a filter.

A comprehension evaluates the body e (as in for (enumerators) yield e) for each binding generated by the enumerators and returns a sequence of these values.

def even(from: Int, to: Int): List[Int] = for (i <- List.range(from, to) if i % 2 == 0) yield i

Every datatype that supports the operations filterWith, map, and flatMap (with the proper types) can be used in sequence comprehensions.

There is also a special form of sequence comprehension which returns Unit. Here the bindings that are created from the list of generators and filters are used to perform side-effects. The programmer has to omit the keyword yield to make use of such a sequence comprehension.

no yield keyword - uses the special for comprehension returning Unit:

object ComprehensionTest3 extends App {
  for (i <- Iterator.range(0, 20);
       j <- Iterator.range(i, 20) if i + j == 32)
    println("(" + i + ", " + j + ")")
}

In Scala, patterns can be defined independently of case classes. To this end, a method named unapply is defined to yield a so-called extractor.

the following code defines an extractor object Twice. The pattern case Twice(n) will cause an invocation of Twice.unapply

object Twice {
  def apply(x: Int): Int = x * 2
  def unapply(z: Int): Option[Int] = if (z%2 == 0) Some(z/2) else None
}

object TwiceTest extends App {
  val x = Twice(21)
  x match { case Twice(n) => Console.println(n) } // prints 21
} 

The apply method is not necessary for pattern matching. It is only used to mimick a constructor. val x = Twice(21) expands to val x = Twice.apply(21).

Like in Java 5, Scala has built-in support for classes parameterized with types, e.g. Stack[T]

subtyping of generic types is *invariant*. This means that if we have a stack of characters of type Stack[Char] then it cannot be used as an integer stack of type Stack[Int]. This would be unsound because it would enable us to enter true integers into the character stack.

Scala supports variance annotations of type parameters of generic classes. In contrast to Java 5 (aka. JDK 1.5), variance annotations may be added when a class abstraction is defined, whereas in Java 5, variance annotations are given by clients when a class abstraction is used.

the type defined by the class Stack[T] is subject to invariant subtyping regarding the type parameter.

The annotation +T declares type T to be used only in covariant positions.

Similarly, -T would declare T to be used only in contravariant positions.

For covariant type parameters we get a covariant subtype relationship regarding this type parameter. For our example this means Stack[T] is a subtype of Stack[S] if T is a subtype of S. The opposite holds for type parameters that are tagged with a -.

A method with implicit parameters can be applied to arguments just like a normal method. In this case the implicit label has no effect. However, if such a method misses arguments for its implicit parameters, such arguments will be automatically provided.

In Scala it is possible to let classes have other classes as members. Opposed to Java-like languages where such inner classes are members of the enclosing class, in Scala such inner classes are bound to the outer object.

Typically, parameters to functions are by-value parameters; that is, the value of the parameter is determined before it is passed to the function. But what if we need to write a function that accepts as a parameter an expression that we don't want evaluated until it's called within our function? For this circumstance, Scala offers call-by-name parameters.

A call-by-name mechanism passes a code block to the callee and each time the callee accesses the parameter, the code block is executed and the value is calculated.

takes a call-by-name parameter by putting the => symbol between the variable name and the type.

the type of args inside the printStrings function, which is declared as type "String*" is actually Array[String].

default parameter values in function header:
def addInt( a:Int=5, b:Int=7 ) : Int

val date = new Date
val logWithDateBound = log(date, _ : String)
logWithDateBound("message1" )

In a normal function call, the arguments in the call are matched one by one in the order of the parameters of the called function. Named arguments allow you to pass arguments to a function in a different order. The syntax is simply that each argument is preceded by a parameter name and an equals sign.

printInt(b=5, a=7);

def apply(f: Int => String, v: Int) = f(v)