Scribd
Upload
88 views25 pages

Scala

Uploaded by

Abhishek Srivastava
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
88 views25 pages

Scala

Uploaded by

Abhishek Srivastava
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 25

The Scala

Programming
Language
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; Define loopWhile method
loopWhile(cond)(body);
}

var i = 10;
loopWhile (i > 0) { Use it with nice syntax
Console.println(i);
i=i-1
}
}
Scala class hierarchy
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
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 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?
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
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

val s: Set = xs; val s: Set = view(xs);


Suppose xsx : List
xs contains andview(xs)
view above is inx
contains
scope
Compound types
motivation
trait Cloneable { trait Resetable {
def clone(); def reset: Unit;
} }

def cloneAndReset(obj: ?): Cloneable = {


val cloned = obj.clone();
obj.reset;
cloned
}
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

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy