2. First bits
• Scalable language pronounced
as “Sca-lah”
• Developed by Martin Odersky in
2001
• He is also famous for developing
javac
• Currently owns his own
company called Typesafe
3. Motivation
Java Code Scala Code
public class DemoAdd { object DemoAdd {
public static void main(String[] args) { def main(args: Array[String]): Unit = {
int sum = 0; println((1 to 1000).reduceLeft( _ + _ ))
for(int i = 1; i <= 1000; ++i){ }
sum = sum + i; }
}
System.out.println(sum);
}
}
4. Motivation
Java Code Scala Code
public class DemoList { object DemoList {
public static void main(String[] args) {
def main(args:Array[String]):Unit = {
List<String> ls = new val ls = List("One", "Two", "Three", "Four")
ArrayList<String>();
for(xs <- ls) println(xs)
ls.add(“One"); }
ls.add(“Two"); }
ls.add(“Three");
Iterator it = ls.iterator();
while(it.hasNext()){
String value=(String)it.next();
System.out.println(value);
}
}
}
5. Motivation
• Code size is much smaller compared to Java
• Less verbose
• Functional Programming(FP) + Object oriented
• Statically typed
• JVM based
• .NET (CLR) support
• Scalable – from small to large distributed
systems
8. Classes and Objects
class DemoClass {
var name:String = ""
}
object Demo{
def main (args:Array[String]):Unit = {
val hello = new DemoClass
hello name = "Hello"
println(hello name)
}
}
9. Classes and Objects
public class Person{ class Person(age: Int, name: String) {
override def toString = age + " " + name
private int m_age = 0; }
private String m_name = "";
object DemoConstr {
Person(int age, String name){
m_age = age; def main(args: Array[String]): Unit = {
m_name = name; val person = new Person(10, "John")
} println(person)
}
public static void main(String[] args) { }
Person person = new Person(10, "John");
System.out.println(person.m_age + " " +
person.m_name);
}
}
10. Functional Programming (FP)
• Learning FP is challenging
• Functions are first-class citizens
• In FP, constraint is “no state” and “immutable”
– Other words FP does not allow “side effects”
– Reassigning a variable
– Modifying DS in place
• FP allows programming using “pure functions”
11. FP Pure Functions
val x = "Hello, World"
x: java.lang.String = Hello, World
val r1 = x.reverse
r1: String = dlroW ,olleH
val r2 = x.reverse
r2: String = dlroW ,olleH x is referentially transparent
After substitution, the output
Substitute “x” with its value remains same – “no side
effects”
scala> val r1 = "Hello, World".reverse
r1: String = dlroW ,olleH
val r2 = "Hello, World".reverse
r2: String = dlroW ,olleH
12. FP Pure Functions
val x = new StringBuilder("Hello")
x: java.lang.StringBuilder = Hello
val y = x.append(", World")
y: java.lang.StringBuilder = Hello, World
val r1 = y.toString
r1: java.lang.String = Hello, World
val r2 = y.toString
r2: java.lang.String = Hello, World
13. FP Pure Functions
val x = new StringBuilder("Hello")
x: java.lang.StringBuilder = Hello
val r1 = x.append(", World").toString
r1: java.lang.String = Hello, World
val r2 = x.append(", World").toString
r2: java.lang.String = Hello, World, World
x is not referentially
transparent
After substitution, the output
Is different– “side effects”
14. FP
object NumOfElems{
def length[A](ls: List[A]): Int = ls match {
case Nil => 0
case _ :: tail => 1 + length(tail)
case _ => throw new NoSuchElementException
}
def main(args: Array[String]): Unit = {
println(List(1, 2, 4, 5, 98, 23, 53).length)
println(length(List(1, 2, 4, 5, 98, 23, 53)))
}
}
16. FP
• This works for small lists, but what if you have a very large list ?!
• Don’t give up on “Recursion”, we have a solution for that
• Remember, “Recursion is the bread and butter of FP”
17. FP - Tail call optimisation
def length[A](ls: List[A]): Int = ls match { def lengthTR[A](ls: List[A]):Int = {
case Nil => 0
case _ :: tail => 1 + length(tail) def loop(ls:List[A], acc:Int):Int = ls match{
case _ => throw new NoSuchElementException case Nil => acc
} case _ :: tail => loop(tail, acc + 1)
}
loop(ls,0)
}
19. Pattern Matching
object DemoRegEx {
def main(args:Array[String]):Unit = {
val Date = """(dd)/(dd)/(dddd)""".r
val date = "01/02/2013"
val Date(day, month, year) = date
println(day)
println(month)
println(year)
}
}
20. Final thoughts
• Scala is great for general purpose computing
• Scales well and has an elegant syntax
• Neat integration with Java
• Great RegEx support
• Actors replaces Threads in Java for
concurrency
