Introduction to Scala Lecture 1

CMSC 331 SD Vick

Whats Scala and why should You Care? Care?

Its language written by by Martin Odersky at EPFL (cole Polytechnique Fdrale de Lausanne (EPFL), Lausanne, Switzerland Influenced by ML/Haskell, Java and other languages with better support for component software Its a scalable Programming language for component software with a focus is on abstraction, composition, and decomposition and abstraction, composition, not on primitives It unifies OOP and functional programming It interoperates with Java and .NET
2

(Coming from Java/C++) (Coming

Runs on the JVM Can use any Java code in Scala Almost as fast as Java (within 10%) Much shorter code Odersky reports 50% reduction in most code over Java Local type inference Fewer errors No Null Pointer problems More flexibility As many public classes per source file as you want Operator overloading

Why Scala?

Getting Started in Scala

scala
Runs compiled scala code Or without arguments, as an interpreter!

scalac - compiles fsc - compiles faster! (uses a background server to minimize startup time) Go to scala-lang.org for downloads/documentation Read Scala: A Scalable Language (see http://www.artima.com/scalazine/articles/scalablelanguage.html )
4

Features of Scala
Scala is both functional and object-oriented
every value is an object every function is a value--including methods includes a local type inference system: in Java 1.5:
Pair<Integer, String> p = new Pair<Integer, String>(1, "Scala");

Scala is statically typed

in Scala:
val p = new MyPair(1, "scala");

Scala The Interpreter

Easiest way to get started with Scala is by using the Scala interpreter, which is an interactive shell for writing Scala expressions Simply type an expression into the interpreter and it will evaluate the expression and print the resulting value. $ scala This is an interpreter for Scala. Type in expressions to have them evaluated. Type :help for more information. scala> After you type an expression, such as 1 + 2, and hit return: scala> 1 + 2 The interpreter will print:

unnamed0: Int = 3 This line includes: an automatically assigned or user-defined name to refer to the computed value (unnamed0) a colon (:) the type of the expression and its resulting value (Int) an equals sign (=) the value resulting from evaluating the expression (3)
6

More features
Supports lightweight syntax for anonymous functions, higher-order functions, nested functions, currying ML-style pattern matching Integration with XML
can write XML directly in Scala program can convert XML DTD into Scala class definitions

Support for regular expression patterns

Other features
Allows defining new control structures without using macros, and while maintaining static typing Any function can be used as an infix or postfix operator Can define methods named +, <= or ::
8

Automatic Closure Construction

Allows programmers to make their own control structures Can tag the parameters of methods with the modifier def. When method is called, the actual def parameters are not evaluated and a noargument function is passed

While loop example

object TargetTest1 with Application { def loopWhile(def cond: Boolean)(def body: Unit): Unit = if (cond) { body; Define loopWhile method loopWhile(cond)(body); } var i = 10; loopWhile (i > 0) { Console.println(i); i = i 1 } }
10

Use it with nice syntax

Note: var/val

Scala class hierarchy

Scala object system

Class-based Single inheritance Can define singleton objects easily (no need for static which is not really OO) Traits, compound types, and views allow for more flexibility
12

Basic Scala
Use var to declare variables:
var x = 3; x += 4;

Use val to declare values (final vars)

val y = 3; y += 4; // error

Notice no types, but it is statically typed

var x = 3; x = hello world; // error

Type annotations:
var x : Int = 3;
13

Basic Scala
Class instances
val c = new IntCounter[String];

Accessing members (Look Ma no args!)

println(c.size); // same as c.size()

Defining functions:
def foo(x : Int) { println(x == 42); } def bar(y : Int): Int = y + 42; // no braces // needed! def return42 = 42; // No parameters either!

14

Functions, Mapping, Filtering

Defining lambdas nameless functions (types sometimes needed)
val f = x :Int => x + 42; mapping int-> int intf is now a

Closures! A way to haul around state

var y = 3; val g = {x : Int => y += 1; x+y; }

Maps (and a cool way to do some functions)

List(1,2,3).map(_+10).foreach(println)

Filtering (and ranges!)

1 to 100 filter (_ % 7 == 3) foreach (println)
15

(Feels a bit like doing unix pipes?)

Classes and Objects

trait Nat;
object Zero extends Nat { def isZero: boolean = true; def pred: Nat = throw new Error("Zero.pred"); } class Succ(n: Nat) extends Nat { def isZero: boolean = false; def pred: Nat = n; }
16

Traits
Similar to interfaces in Java They may have implementations of methods But cant contain state Can be multiply inherited from

17

More on Traits
Halfway between an interface and a class, called a trait. A class can incorporate as multiple Traits like Java interfaces but unlike interfaces they can also contain behavior, like classes. Also, like both classes and interfaces, traits can introduce new methods. Unlike either, the definition of that behavior isn't checked until the trait is actually incorporated as part of a class.

Example of traits
trait Similarity { def isSimilar(x: Any): Boolean; def isNotSimilar(x: Any): Boolean = !isSimilar(x); } class Point(xc: Int, yc: Int) with Similarity { var x: Int = xc; var y: Int = yc; def isSimilar(obj: Any) = obj.isInstanceOf[Point] && obj.asInstanceOf[Point].x == x; }

19

Mixin class composition

Basic inheritance model is single inheritance But mixin classes allow more flexibility
class Point2D(xc: Int, yc: Int) { val x = xc; val y = yc; // methods for manipulating Point2Ds } class ColoredPoint2D(u: Int, v: Int, c: String) extends Point2D(u, v) { var color = c; def setColor(newCol: String): Unit = color = newCol;

}
20

Mixin class composition example

Point2D

ColoredPoint2D

Point3D

ColoredPoint3D ColoredPoint2D

class Point3D(xc: Int, yc: Int, zc: Int) extends Point2D(xc, yc) { val z = zc; // code for manipulating Point3Ds }

class ColoredPoint3D(xc: Int, yc: Int, zc: Int, col: String) extends Point3D(xc, yc, zc) with ColoredPoint2D(xc, yc, col);

Mixin class composition

Mixin composition adds members explicitly defined in ColoredPoint2D (members that werent inherited) Mixing a class C into another class D is legal only as long as Ds superclass is a subclass of Cs superclass.
i.e., D must inherit at least everything that C inherited

Why?
22

Mixin class composition

Remember that only members explicitly defined in ColoredPoint2D are mixin inherited So, if those members refer to definitions that were inherited from Point2D, they had better exist in ColoredPoint3D
They do, since ColoredPoint3D extends Point3D which extends Point2D

23

Views
Defines a coercion from one type to another Similar to conversion operators in C++/C#
trait Set { def include(x: int): Set; def contains(x: int): boolean } def view(list: List) : Set = new Set { def include(x: int): Set = x prepend xs; def contains(x: int): boolean = !isEmpty && (list.head == x || list.tail contains x) }

24

Views
Views are inserted automatically by the Scala compiler If e is of type T then a view is applied to e if:
expected type of e is not T (or a supertype) a member selected from e is not a member of T

Compiler uses only views in scope Suppose xs : List and view above is in scope
val s: Set = xs; xs contains x val s: Set = view(xs); view(xs); view(xs) view(xs) contains x

Compound types motivation

trait Cloneable { def clone(); } trait Resetable { def reset: Unit; }

def cloneAndReset(obj: ?): Cloneable = { val cloned = obj.clone(); obj.reset; cloned }

26

Compound types
In Java, the solution is:
interface CloneableAndResetable extends Cloneable, Resetable

But if the original object did not use the CloneableAndResetable interface, it wont work Scala solution: use compound types (also called intersection types)

def cloneAndReset(obj: Cloneable with Resetable): Cloneable = { ... }

27

Variance annotations
class Array[a] { def get(index: int): a def set(index: int, elem: a): unit; }

Array[String] is not a subtype of Array[Any] If it were, we could do this:

val x = new Array[String](1); val y : Array[Any] = x; y.set(0, new FooBar()); // just stored a FooBar in a String array!

Variance Annotations
Covariance is ok with functional data structures
trait GenList[+T] { def isEmpty: boolean; def head: T; def tail: GenList[T] } object Empty extends GenList[All] { def isEmpty: boolean = true; def head: All = throw new Error("Empty.head"); def tail: List[All] = throw new Error("Empty.tail"); } class Cons[+T](x: T, xs: GenList[T]) extends GenList[T] { def isEmpty: boolean = false; def head: T = x; def tail: GenList[T] = xs
}
29

Variance Annotations
Can also have contravariant type parameters
Useful for an object that can only be written to

Scala checks that variance annotations are sound

covariant positions: immutable field types, method results contravariant: method argument types Type system ensures that covariant parameters are only used covariant positions (similar for contravariant)

Types as members
abstract class AbsCell { type T; val init: T; private var value: T = init; def get: T = value; def set(x: T): unit = { value = x } } def createCell : AbsCell { new AbsCell { type T = int; val init = 1 } }

Clients of createCell cannot rely on the fact that T is int, since this information is hidden from them

Resources
The Scala programming language home page (see http://www.scala-lang.org/ ) The Scala mailing list (see http://listes.epfl.ch/cgibin/doc_en?liste=scala ) The Scala wiki (see http://scala.sygneca.com/ ) A Scala plug-in for Eclipse (see http://www.scalalang.org/downloads/eclipse/index.html ) A Scala plug-in for IntelliJ (see http://plugins.intellij.net/plugin/?id=1347 )

32

References
The Scala Programming Language as presented by Donna Malayeri (see http://www.cs.cmu.edu/~aldrich/courses/819/slides/scala.ppt ) The Scala Language Specification 2.7 (seehttp://www.scala-lang.org/docu/files/ScalaReference.pdf ) The busy Java developer's guide to Scala: Of traits and behaviorsUsing Scala's version of Java interfaces(see http://www.ibm.com/developerworks/java/library/jscala04298.html ) First Steps to Scala (in Scalazine) by Bill Venners, Martin Odersky, and Lex Spoon, May 9, 2007 (see http://www.artima.com/scalazine/articles/steps.html )

33