Transcript
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
top related