A Brief Intro to Scala

A Brief Intro to ScalaTim Underwood

About MeTim UnderwoodCo-Founder of Frugal MechanicSoftware DeveloperPerl, PHP, C, C++, C#, Java, Ruby and now ScalaBefore Scaladefault languages were Ruby and Java

Dynamic vs. StaticDynamic (Ruby)Static (Java)ConciseScriptableRead-Eval-Print Loop (irb)Higher Order FunctionsExtend existing classesDuck Typingmethod_missingBetter IDE SupportFewer TestsDocumentationOpen Source LibsPerformanceJVM Tools (VisualVM)True Multi-threading

True Multi-threadingScalable language

Scalais a modern multi-paradigm programming language designed to express common programming patterns in a concise, elegant, and type-safe way.

ScalaStatically TypedRuns on JVM, full inter-op with JavaObject OrientedFunctionalDynamic Features

Scala is PracticalCan be used as drop-in replacement for JavaMixed Scala/Java projectsUse existing Java librariesUse existing Java tools (Ant, Maven, JUnit, etc…)Decent IDE Support (NetBeans, IntelliJ, Eclipse)

Type Inferenceval sum = 1 + 2 + 3valnums = List(1, 2, 3)val map = Map("abc" -> List(1,2,3))

Explicit Typesval sum:Int= 1 + 2 + 3valnums:List[Int]= List(1, 2, 3)val map:Map[String, List[Int]] = ...

Higher Level// Java – Check if string has uppercase characterbooleanhasUpperCase = false;for(inti = 0; i < name.length(); i++) {if(Character.isUpperCase(name.charAt(i))) {hasUpperCase = true;break; }}

Higher Level// ScalavalhasUpperCase = name.exists(_.isUpperCase)

Less Boilerplate// Javapublic class Person {private String name;private intage;public Person(String name, Intage) { // constructor this.name = name;this.age = age; }public String getName() { // name getter return name; }publicintgetAge() { // age getter return age; }public void setName(Stringname) { // name setter this.name = name; }public void setAge(intage) { // age setterthis.age = age; }}

Less Boilerplate// Scalaclass Person(varname: String, varage: Int)

Less Boilerplate// Scalaclass Person(var name: String, privatevar _age: Int) { defage = _age// Getter for age defage_=(newAge:Int) { // Setter for ageprintln("Changing age to: "+newAge)_age = newAge }}

Variables and Values// variablevarfoo = "foo"foo = "bar" // okay// valuevalbar = "bar"bar = "foo"// nope

Pure O.O.// Every value is an object1.toString// Every operation is a method call1 + 2 + 3  (1).+(2).+(3)// Can omit . and ( )"abc" charAt 1  "abc".charAt(1)

Classes// Classes (and abstract classes) like Javaabstract classLanguage(valname:String) {override deftoString = name}// Example implementationsclassScalaextendsLanguage("Scala")// Anonymous classvalscala = newLanguage("Scala") { /* empty */ }

Traits// Like interfaces in Javatrait Language {valname:String// But allow implementationoverridedeftoString = name}

TraitstraitJVM { override deftoString = super.toString+" runs on JVM" }traitStatic { override deftoString = super.toString+" is Static" }// Traits are stackableclassScalaextends Language with JVM with Static {val name = "Scala"}println(newScala) "Scala runs on JVM is Static"

Singleton Objects// Replaces static methods from Java// Can extend/implement classes & traitsobject Hello { def world = println("Hello World"}}Hello.world Hello World

First Class Functions// Lightweight anonymous functions(x:Int) => x + 1// Calling the anonymous functionvalplusOne = (x:Int) => x + 1plusOne(5)  6

Closures// plusFoo can reference any values/variables in scopevarfoo= 1valplusFoo = (x:Int) => x + fooplusFoo(5)  6// Changing foo changes the return value of plusFoofoo= 5plusFoo(5)  10

Higher Order FunctionsvalplusOne = (x:Int) => x + 1valnums = List(1,2,3)// map takes a function: Int => Tnums.map(plusOne)  List(2,3,4)// Inline Anonymousnums.map(x => x + 1)  List(2,3,4)// Short formnums.map(_ + 1)  List(2,3,4)

Higher Order Functionsvalnums = List(1,2,3,4)// A few more examples for List classnums.exists(_ == 2)  truenums.find(_ == 2)  Some(2)nums.indexWhere(_ == 2)  1nums.reduceLeft(_ + _)  10nums.foldLeft(100)(_ + _)  110// Many more in collections library

Higher Order Functions// functions as parametersdefcall(f: Int => Int) = f(1)call(plusOne)  2call(x => x + 1)  2call(_ + 1)  2

Higher Order Functions// functions as parametersdefeach(xs: List[Int], fun: Int => Unit) {if(!xs.isEmpty) {fun(xs.head)each(xs.tail, fun) }}each(List(1,2,3), println) 1 2 3

Higher Order Functions// More complex example with generics & patternmatching@tailrecdefeach[T](xs: List[T], fun: T => Unit): Unit = xsmatch{caseNil =>casehead :: tail => fun(head); each(tail, fun)}each(List(1,2), println) 1 2each(List("foo", "bar"), println)foo bar

Pattern Matchingdef what(any:Any) = any match {casei:Int => "It's an Int"cases:String => "It's a String"case_ => "I don't know what it is"}what(123)  "It's an Int"what("hello")  "It's a String"what(false)  "I don't know what it is"

Pattern Matchingvalnums = List(1,2,3)// Pattern matching to create 3 valsvalList(a,b,c) = numsa  1b 2c 3

Immutable Types// Immutable types by defaultvarnums = Set(1,2,3)nums+= 4 nums= nums.+(4)// Mutable types availableimportscala.collection.mutable._valnums = Set(1,2,3)nums+= 4 nums.+=(4)

Or Use Existing Java Collectionsjava.utilApache Commons CollectionsfastutilTroveGoogle Collectionsscala.collection.JavaConversion available to convert to and from java.util Interfaces

Scalais Dynamic(Okay not really, but it has lots of features typically only found in Dynamic languages)

Scriptable// HelloWorld.scalaprintln("Hello World")bash$scalaHelloWorld.scalaHello Worldbash$scala -e 'println("Hello World")'Hello World

Read-Eval-Print Loopbash$scalaWelcome to Scala version 2.8.1.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_22).Type in expressions to have them evaluated.Type :help for more information.scala>class Foo { def bar = "baz" }defined class Fooscala>valf = new Foof: Foo = Foo@51707653scala> f.barres2: java.lang.String = baz

Structural Typing// Type safe Duck Typingdef doTalk(any:{deftalk:String}) {println(any.talk)}class Duck { def talk = "Quack" }class Dog { def talk = "Bark" }doTalk(new Duck)  "Quack"doTalk(new Dog)  "Bark"

Implicit Conversions// Extend existing classes in a type safe way// Goal: Add isBlank method to String classclassRichString(s:String) { defisBlank = null == s || "" == s.trim}implicit deftoRichString(s:String) = newRichString(s)// Our isBlank method is now available on Strings" ".isBlanktrue"foo".isBlankfalse

Implicit Conversions// Does not type check"abc".isBlank// Search in-scope implicitsdefs that take a// String & return a type with an isBlank methodimplicit deftoRichString(s:String):RichString// Resulting code that type checksnewRichString("abc").isBlank

A Brief Intro to Scala

More Related Content

What's hot

Viewers also liked

Similar to A Brief Intro to Scala

Recently uploaded

In this document

A Brief Intro to Scala