Introducing Scala A better and tastier java Byju

Introducing Scala. A better and tastier java Byju Veedu 16 Dec 2010 Courtesy for Sources http: //www. scala-lang. org/ http: //www. slideshare. net/Odersky/fosdem-2009 -1013261 http: //www. slideshare. net/stal 42/oop 2010 -scala-presentation-stal http: //www. slideshare. net/jboner/pragmatic-real-world-scala-45 -min-presentation

Objectives • • • Why scala ? Why it is scalable ? Where it is superior to java ? How scala combines OO and FP ? How type inference works in scala ? Actor concurrency model Functional programming As fast as java Scala is fun for developers

History • Scala was designed from 2001 by Martin Odersky and his group at EPFL in Lausanne, Switzerland. • Odersky had previously worked on Generic Java and javac, Sun's Java compiler. • The goal was to combine functional and object-oriented programming, but without the restrictions imposed by the Java language. The first step in this direction was Funnel • The second step scala took some of the ideas of Funnel and put them into a more pragmatic language with special focus on interoperability with standard platforms • Scala was released late 2003 / early 2004 on the Java platform, and on the. NET platform in June 2004. • As of November 2010, the latest release is version 2. 8. 1

Scala is • • • Statically typed Functional Pure Object oriented Compiles to byte code and runs in jvm Interoperate with java Type inference Concurrency with actors Mixins with traits Immutable collections Scripting language As fast as java

Scalable language • A language is scalable if it is suitable for very small as well as very large programs. • A single language for extension scripts and the heavy lifting. • Application-specific needs are handled through libraries and embedded DSL's instead of external languages. • Scala shows that this is possible.

Hello world class Hello. World( val name: String){ def print = println("Hello world "+name) } object Hello. World. Main(){ def main(args: Array[String]): Unit = { var hello = new Hello. World("Scala") hello print } }

Application base class object Hello. World extends Application { println("Hello world") }

Scala is a scripting language It has an interactive read-eval-print-loop (REPL). Types can be inferred. Boilerplate is scrapped Simple and expressive. scala> var capital = Map("US" "Washington", "France" "Paris") capital: Map[String, String] = Map(US Washington, France Paris) scala> capital += ("Japan" "Tokio") scala> capital("France") res 7: String = Paris

Scala compared to Java Scala adds Scala removes + a pure object system - static members + operator overloading - primitive types + closures - break, continue + mixin composition with traits - special treatment of interfaces + existential types - wildcards + abstract types - raw types + pattern matching - enums Modeled in libraries: assert, enums, properties, events, actors, using, queries, …

Type inference Compiler understands the type of variable based on the values assigned even though the programmer doesn’t explicitly specify the type. In scala this works except for method parameters and for return values of recursive functions scala> val name="John" name: java. lang. String = John scala> print(name. length) 4 scala> val age =35 age: Int = 35 scala> print (age+10) 45 scala> def get. Area (length : Int, width: Int) =length*width get. Area: (length: Int, width: Int)Int scala> println(get. Area(10, 20)) 200

High-level • Java boolean has. Upper. Case = false; for (int i = 0; i < name. length(); i++) { if (Character. is. Upper. Case(name. char. At(i))) { has. Upper. Case = true; break; } } • Scala version val has. Upper. Case = name. exists(_. is. Upper. Case)

Concise // Java public class Person { private String name; private int age; public Person(String name, int age) { this. name = name; this. age = age; } public String get. Name() { return name; } public int get. Age() { return age; } public void set. Name(String name) { this. name = name; } public void set. Age(age: int) { this. age = age; } } // Scala class Person( var name: String, var age: Int)

Pure OO • Every value is an object • Every operation is a method call • Exceptions to these rules in Java (such as primitive types, statics) are eliminated 1+2 1. +(2) 123. to. String()

Inheritance • • Scala classes can be derived from at most one base class Classes may be abstract You need to specify whether you override inherited methods abstract class Shape{ type identifier =Int //abstract type def get. Id: Identifier =12 def draw: String } class Circle (val cx: Double, val cy: Double, val r: Double) extends Shape{ val id: Identifier =get. Id() override def draw: String =”I am circle” } Uniform access principle

Mutable and immutable • Use var and val name =”Scala” // immutable name =”Ruby” // won't compile as name is a val var age =30 age =40 println(age) // prints 40 def place =”Bangalore” // default is val place =”Chennai” // won't compile

Collections • Both mutable and immutable collections • Default is immutable • • List Map Set Tuples

List var list =List(1, 2, 3) or 1 : : 2 : : 3 : : Nil list. head list. tail list. is. Empty list. map(_ + 1) list. filter(_ < 2) list. exists(_ == 3) list. drop(2) list. reverse list. sort(_ > _) List. flatten(list) list. slice(2, 3) // 1 //List(2, 3) // false // List(2, 3, 4) // List(3) // true // List(3) // List(3, 2, 1) // List(1, 2, 3) // List(3)

Map var m 1 =Map(1 ->”scala”, 2 ->”java”) val m 2= m 1+(3 ->”c#”) println(m 2(3)) // new map // add an entry // prints c#

Set • • var s 1 =Set(1, 2, 3, 4) println( s 1 contains 2) // print true var s 3= s 1++s 2 // union var s 4= s 1+5

Tuples def get. Name. And. Age = { val name = “kumar” val age = 25 (name, age) } val (name, age) = get. Name. And. Age println(“Name: “ + name) println(“Age: “ + age)

Exception Handling • No checked exceptions and throws try { int a = 12/arg } catch { case ex: Runtime. Exception => println (“Cannot divide by arg”) case _ => println (“Un expected probem”) } finally{ println(“resources closed”) }

class Data(bytes: • Send (!) is asynchronous; withcase Cuncurrency Actors Array[Byte]) messages are buffered in an actor's mailbox. • receive picks the first message in the mailbox which matches any of the patterns msgpati. • If no pattern matches, the actor suspends case class Sum(receiver: Actor) val check. Sum. Calculator = actor { var sum = 0 loop { receive { case Data(bs) => sum += hash(bs) case Sum(receiver) => receiver ! sum } }

Native xml support def users = <users> <user role=”customer”> <name>{ user. name }</name> <password>{ user. password }</password> <email>{ user. email }</email> </user>. . . </users> users match { case <users>{users @ _*}</users> => for (user <- users) println(“User “ + (user “name”). text) }

Traits and mixin composition class Man(val name: String) extends Human trait Dad { private var children: List[Child] = Nil def add. Child(child: Child) = children = child : : children def get. Children = children. clone } // static mixin composition class Man(val name: String) extends Human with Dad val jonas = new Man(“Jonas”) jonas. add. Child(new Child(“Jacob”)) //Dynamic mixin composition val jonas = new Man(“Jonas”) with Dad jonas. add. Child(new Child(“Jacob”))

Composition with traits trait Entity {. . . } trait Inventory. Item. Set {. . . } trait Invoicable {. . . } trait Purchase. Limiter {. . . } trait Mail. Notifier {. . . } trait ACL {. . . } trait Versioned {. . . } trait Transactional {. . . } val order = new Order(customer) with Entity with Inventory. Item. Set with Invoicable with Purchase. Limiter with Mail. Notifier with ACL with Versioned with Transactional

Structural Typing: Duck-typing done right “ if it walks like a duck… and talks like a duck… then it’s a duck “ def authorize(target: { def get. ACL: ACL }) = { val acl = target. ACL. . . //authorize }

Functions • Scala is a functional language, in the sense that every function is a value. • Functions can be anonymous, curried, nested. • Functions as values val inc = (x: Int) => x + 1 inc(1) // gives 2 • Functions as parameters List(1, 2, 3). map((x: Int) => x + 1) => List(2, 3, 4) • Functions as closures var more = 7 val add. More = (x: Int) => x + more add. More(3) // gives 10 //change more’s value to 8 more = 8 add. More(3) // gives 11

Functions are objects • If functions are values, and values are objects, it follows that functions themselves are objects. The function type S => T is equivalent to scala. Function 1[S, T], where Function 1 is defined as follows: trait Function 1[-S, +T] { def apply(x: S): T } • So functions are interpreted as objects with apply methods. • For example, the anonymous successor function (x: Int ) => x + 1 • is expanded to: new Function 1[Int, Int] { def apply(x: Int) = x + 1 }

Everything returns a value def get. Things. From. Somewhere( from. Here: Boolean): List[Thing] = { try { if (from. Here) { for (thing <- things. From. Here) yield get. Real. Thing(thing) } else { for (thing <- things. From. There) yield thing } } catch { case e => error(e); Nil } }

For comprehensions // Find all attendees named “Fred” that speaks Danish for { att <- attendees if att. name == “Fred” lang <- att. spoken. Languages if lang == “Danish” } println(att) // Yielding val companies. For. Attendees. From. London = for { att <- attendees if att. address. city == “London” } yield att. company

Pattern matching def match. Any(a: Any): Any = a match { case 1 => “one” case “two” => 2 case i: Int => “scala. Int” case <tag>{ t }</tag> => t case head : : tail => head case _ => “default” }

Regular expressions val pattern =“““dd”””. r //. r indicate reg exp val sentence =“X was born on 02. 09. 2010” println(pattern find. First. In sentence) // gives Some(02. 09. 2010)

Adding new control structures • using for resource control (proposed for Java 7) • using (new Buffered. Reader(new File. Reader(path))) { f => println(f. read. Line()) } Instead of • val f = new Buffered. Reader(new File. Reader(path)) try { println(f. read. Line()) } finally { if (f != null) f. close() } Can be implemented as • def using[T <: { def close() }] (resource: T) (block: T => Unit) { try { block(resource) } finally { if (resource != null) resource. close() } }

What makes Scala scalable? strong typing, inference, little boilerplate, … But mainly, its tight integration of functional and object-oriented programming • Functional programming: Makes it easy to build interesting things from simple parts, using ▫ higher-order functions, ▫ algebraic types and pattern matching, ▫ parametric polymorphism • Object-oriented programming: Makes it easy to adapt and extend complex systems, using ▫ subtyping and inheritance, ▫ dynamic configurations, ▫ classes as partial abstractions.

Scala is the Java of the future • It has basically everything Java has now. (sometimes in different form) • It has closures and other functional features (proposed for Java 7, but rejected) • It has traits and pattern matching. (I would not be surprised to see them in Java 8, 9 or 10) • It compiles to. class files, is completely interoperable and runs about as fast as Java • It has type inference to remove boiler plate code • It is pure OO (no primitives) • Simple and succinct syntax • Actors for better concurrency • Native xml support

References • • • http: //www. scala-lang. org/ http: //www. artima. com/scalazine/articles/steps. html http: //programming-scala. labs. oreilly. com/ http: //www. naildrivin 5. com/scalatour/wiki_pages/Main. Page http: //www. simplyscala. com/ http: //www. diigo. com/user/byjupv/Scala. Videos? type=all http: //daily-scala. blogspot. com/ http: //grahamhackingscala. blogspot. com/ http: //www. defmacro. org/ramblings/fp. html http: //davetron 5000. github. com/scala-style/ http: //www. planetscala. com/