on 16-Aug-2014 (Sat)

The following expression creates a successor function for integers:

var inc = (x:Int) => x+1

Variable inc is now a function that can be used the usual way:

var x = inc(7)-1

Curried functions are defined with multiple parameter lists, as follows:

def strcat(s1: String)(s2: String) = s1 + s2

Alternatively, you can also use the following syntax to define a curried function:

def strcat(s1: String) = (s2: String) => s1 + s2

syntax to call a curried function:

strcat("foo")("bar")

lists are immutable

lists represent a linked list

All lists can be defined using two fundamental building blocks, a tail Nil and ::, which is pronounced cons. Nil also represents the empty list. All the above lists can be defined as follows:

// List of Strings
val fruit = "apples" :: ("oranges" :: ("pears" :: Nil))

Concatenating Lists:

You can use either ::: operator or List.:::() method or List.concat() method to add two or more lists.

By default, Scala uses the immutable Set. If you want to use the mutable Set, you'll have to import scala.collection.mutable.Set class explicitly.

If you want to use both mutable and immutable sets in the same, then you can continue to refer to the immutable Set as Set but you can refer to the mutable Set as mutable.Set.

Concatenating Sets:

You can use either ++ operator or Set.++() method to concatenate two or more sets,

By default, Scala uses the immutable Map. If you want to use the mutable Set, you'll have to import scala.collection.mutable.Map class explicitly.

If you want to use both mutable and immutable Maps in the same, then you can continue to refer to the immutable Map as Map but you can refer to the mutable set as mutable.Map.

If we want to add a key-value pair to a Map, we can use the operator + as follows:

A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)

example to declare immutable Maps as follows:

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Concatenating Maps

You can use either ++ operator or Map.++() method to concatenate two or more Maps,

Scala tuple combines a fixed number of items together so that they can be passed around as a whole.

Unlike an array or list, a tuple can hold objects with different types but they are also immutable.

Here is an example of a tuple holding an integer, a string, and the console:

val t = (1, "hello", Console)

Which is syntactic sugar (short cut) for the following:

val t = new Tuple3(1, "hello", Console)

The actual type of a tuple depends upon the number and of elements it contains and the types of those elements. Thus, the type of (99, "Luftballons") is Tuple2[Int, String]. The type of ('u', 'r', "the", 1, 4, "me") is Tuple6[Char, Char, String, Int, Int, String]

Tuples are of type Tuple1, Tuple2, Tuple3 and so on. There currently is an upper limit of 22 in the Scala if you need more, then you can use a collection, not a tuple.

Given the following definition:

val t = (4,3,2,1)

To access elements of a tuple t, you can use method t._1 to access the first element, t._2 to access the second, and so on. For example, the following expression computes the sum of all elements of t:

val sum = t._1 + t._2 + t._3 + t._4

Scala Option[T] is a container for zero or one element of a given type.

An Option[T] can be either Some[T] or None object, which represents a missing value.

use getOrElse() to access a value or a default when no value is present:

in Scala we cannot have static members. Instead, Scala has singleton objects.

A singleton is a class that can have only one instance, i.e., object. You create singleton using the keyword object instead of class keyword.

Since you can't instantiate a singleton object, you can't pass parameters to the primary constructor.

You already have seen all the examples using singleton objects where you called Scala's main method.

A trait encapsulates method and field definitions, which can then be reused by mixing them into classes.

Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits.

traits may not have constructor parameters (also called class parameters)

Child classes extending a trait can give implementation for the un-implemented methods.

a trait is very similar to what we have abstract classes in Java.

val pattern = "Scala".r

We create a String and call the r( ) method on it. Scala implicitly converts the String to a RichString and invokes that method to get an instance of Regex.

An extractor in Scala is an object that has a method called unapply as one of its members.

The purpose of that unapply method is to match a value and take it apart.

Often, the extractor object also defines a dual method apply for building values, but this is not required.

// The injection method (optional)
def apply(user: String, domain: String) = { user +"@"+ domain }

// The extraction method (mandatory)
def unapply(str: String): Option[(String, String)] = {
  val parts = str split "@"
  if (parts.length == 2) { Some(parts(0), parts(1)) }
  else{ None }
}