scala.ppt

The Scala Programming
Language
presented by Donna Malayeri

Why a new language?
 Goal was to create a language with better support
for component software
 Two hypotheses:
 Programming language for component software
should be scalable
 The same concepts describe small and large parts
 Rather than adding lots of primitives, focus is on
abstraction, composition, and decomposition
 Language that unifies OOP and functional
programming can provide scalable support for
components
 Adoption is key for testing this hypothesis
 Scala interoperates with Java and .NET

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

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 ::

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 no-
argument function is passed

While loop example
object TargetTest1 with Application {
def loopWhile(def cond: Boolean)(def body: Unit): Unit =
if (cond) {
body;
loopWhile(cond)(body);
}
var i = 10;
loopWhile (i > 0) {
Console.println(i);
i = i - 1
}
}
Define loopWhile method
Use it with nice syntax

Scala object system
 Class-based
 Single inheritance
 Can define singleton objects easily
 Subtyping is nominal
 Traits, compound types, and views allow for
more flexibility

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

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

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

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

Mixin class composition example
ColoredPoint2D
Point2D
class Point3D(xc: Int, yc: Int, zc: Int)
extends Point2D(xc, yc) {
val z = zc;
// code for manipulating Point3Ds
}
Point3D
class ColoredPoint3D(xc: Int, yc: Int, zc: Int, col: String)
extends Point3D(xc, yc, zc)
with ColoredPoint2D(xc, yc, col);
ColoredPoint3D
ColoredPoint2D

 Mixin composition adds members explicitly
defined in ColoredPoint2D
(members that weren’t inherited)
 Mixing a class C into another class D is legal
only as long as D’s superclass is a subclass of
C’s superclass.
 i.e., D must inherit at least everything that C
inherited
 Why?

 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

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

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) contains x

Compound types motivation
def cloneAndReset(obj: ?): Cloneable = {
val cloned = obj.clone();
obj.reset;
cloned
}
trait Resetable {
def reset: Unit;
}
trait Cloneable {
def clone();
}

Compound types
 In Java, the “solution” is:
interface CloneableAndResetable extends
Cloneable, Resetable
 But if the original object did not use the
CloneableAndResetable interface, it won’t
work
 Scala solution: use compound types (also
called intersection types)
def cloneAndReset(obj: Cloneable with Resetable):
Cloneable = {
...
}

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
}

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

Discussion/Critiques
 Scala has nominal subtyping. Is this good?
 Inheritance and subtyping are conflated in
Scala. Shouldn’t they be separated?
 Mixins in MzScheme vs. Scala – MzScheme
allows a class to parameterize its supertype,
while Scala does not
 Type system does not distinguish null
references from non-null references

scala.ppt

More Related Content

Similar to scala.ppt (20)

Recently uploaded (20)

scala.ppt