Scala

Introduction to Scala

Suraj [email protected]

@suraj2585

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

Motivation

Java Code

public class DemoAdd {

public static void main(String[] args) {

int sum = 0;

for(int i = 1; i <= 1000; ++i){sum = sum + i;

} System.out.println(sum); }}

Scala Code

object DemoAdd {

def main(args: Array[String]): Unit = {

println((1 to 1000).reduceLeft( _ + _ ))

}}

Scala Code

object DemoList {

def main(args:Array[String]):Unit = { val ls = List("One", "Two", "Three", "Four") for(xs <- ls) println(xs) }}

Java Code

public class DemoList {

public static void main(String[] args) {

List<String> ls = new ArrayList<String>();

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); } }}

Motivation

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

Motivation

• Seamless integration with Java• Hot language • Facebook, Twitter, LinkedIn, Foursquare

IDE

• http://www.scala-lang.org/• Eclipse plugin (http://www.eclipse.org)• IntelliJ (http://www.jetbrains.com/idea/)

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) }}

Classes and Objectsclass Person(age: Int, name: String) { override def toString = age + " " + name}

object DemoConstr {

def main(args: Array[String]): Unit = { val person = new Person(10, "John") println(person) }}

public class Person{

private int m_age = 0; private String m_name = "";

Person(int age, String name){ m_age = age; m_name = name; }

public static void main(String[] args) {

Person person = new Person(10, "John"); System.out.println(person.m_age + " " +

person.m_name); }}

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”

FP Pure Functions

val x = "Hello, World"x: java.lang.String = Hello, World

val r1 = x.reverser1: String = dlroW ,olleH

val r2 = x.reverser2: String = dlroW ,olleH

Substitute “x” with its value scala> val r1 = "Hello, World".reverse

r1: String = dlroW ,olleHval r2 = "Hello, World".reverse

r2: String = dlroW ,olleH

x is referentially transparent

After substitution, the outputremains same – “no side effects”

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.toStringr1: java.lang.String = Hello, World

val r2 = y.toStringr2: java.lang.String = Hello, World

FP Pure Functions

val x = new StringBuilder("Hello")x: java.lang.StringBuilder = Hello

val r1 = x.append(", World").toStringr1: java.lang.String = Hello, World

val r2 = x.append(", World").toStringr2: java.lang.String = Hello, World, World

x is not referentially transparent

After substitution, the outputIs different– “side effects”

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))) }

}

FP 1 + length(List(2, 4, 5, 98, 23, 53))

1 + (1 + length(List(4, 5, 98, 23, 53)))

1 + (1 + (1 + length(List(5, 98, 23, 53))))

1 + (1 + (1 + (1 + length(List(98, 23, 53)))))

1 + (1 + (1 + (1 + (1 + length(List(23, 53))))))

1 + (1 + (1 + (1 + (1 + (1 + length(List(53)))))))

1 + (1 + (1 + (1 + (1 + (1 + (1 + length(List())))))))

1 + (1 + (1 + (1 + (1 + (1 + (1 + 0)))))))

1 + (1 + (1 + (1 + (1 + (1 + 1)))))

1 + (1 + (1 + (1 + (1 + 2))))

1 + (1 + (1 + (1 + 3)))

1 + (1 + (1 + 4))

1 + (1 + 5)

1 + 6

7

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”

FP - Tail call optimisation

def lengthTR[A](ls: List[A]):Int = { def loop(ls:List[A], acc:Int):Int = ls match{ case Nil => acc case _ :: tail => loop(tail, acc + 1) } loop(ls,0) }

def length[A](ls: List[A]): Int = ls match { case Nil => 0 case _ :: tail => 1 + length(tail) case _ => throw new NoSuchElementException }

FP - Tail call optimisationloop(List(2, 4, 5, 98, 23, 53), 0 + 1)

loop(List(4, 5, 98, 23, 53), 1 + 1)

loop(List(5, 98, 23, 53), 2 + 1)

loop(List(98, 23, 53), 3 + 1)

loop(List(23, 53), 4 + 1)

loop(List(53), 5 + 1)

loop(List(), 6 + 1)

7

def lengthTR[A](ls: List[A]):Int = { def loop(ls:List[A], acc:Int):Int = ls match{ case Nil => acc case _ :: tail => loop(tail, acc + 1) } loop(ls,0) }

Pattern Matchingobject DemoRegEx {

def main(args:Array[String]):Unit = { val Date = """(\d\d)/(\d\d)/(\d\d\d\d)""".r val date = "01/02/2013" val Date(day, month, year) = date println(day) println(month) println(year) } }

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

E0F