Scala

Vortrag im Rahmen des Seminars „Programmiersprachen“

David Ullrich

In diesem Vortrag erwartet Sie:

Einführung Besonderheiten der Sprache Beispiel-Anwendung: QuickSort Zusammenfassung

Einführung

Der Ursprung Gründe für eine neue Sprache Zielsetzung beim Entwurf

Der Ursprung

Prof. Martin Odersky (Pizza, GJ) Programming Methods Laboratory - LAMP Seit 2002 in der Entwicklung Erste Veröffentlichung Januar 2004

Gründe für eine neue Sprache(nach Odersky)

Zunehmende Verbreitung vonWeb-Services stellt einen Paradigmen-Wechsel dar

Bedarf nach Unterstützung durch Programmiersprachen entsteht

Ziele beim Entwurf

Verknüpfung von funktionaler und Objekt-Orientierter Programmierung

Kein Flickwerk Synergie Nahtlose Zusammenarbeit mit anderen

Objekt-Orientierten Sprachen Pattern-Matching als Grundlage für

XML-Bearbeitung

Besonderheiten der Sprache

Das Typsystem Klassen und Vererbung Funktionen Framework-Integration Fortgeschrittene Konzepte

Das Typsystem

„Alles ist ein Objekt“ klassische Objekte aus der OOP Funktionen Werte Objekte

object ObjektDemo { def main(args: Array[String]): unit = System.out.println(main.toString());}

Objekthierarchie in Scala (Auswahl)

scala.AnyVal

scala.Any

scala.AnyRef

(java.lang.Object)

scala.Int

scala.Char

scala.Object java.lang.String

Benutzerdefinierte Typumwandlung

Werttypen besitzen bereits verschiedene coerce-Methoden (Byte Short Int)

coerce-Methoden werden implizit aufgerufen

def coerce: String = { [...]}

Klassen und Vererbung

Singleton-Objekte Klasseninstanzen Vererbung mixin-composition generische Klassen type-bounds

Singleton-Objekte

Schlüsselwort object Referenzierung über den Objektnamen main-Methode bildet Startpunkt

object HelloWorld { def main(args: Array[String]): unit = System.out.println(“Hello World!“);}

object HelloWorld with Application { System.out.println(“Hello World!“);}

Klasseninstanzen

Schlüsselwort class zur Definition Schlüsselwort new zur Instanziierung keine Konstruktoren stattdessen Parameterliste

class Klassendemo(a:int) { val x = a;}

Vererbung

Einfachvererbung mit Schlüsselwort extends

Schnittstellen-Definition über trait abstract Klassen nur Oberklassen sealed Klassen nie Oberklassen Überladen mit override Signatur bei Überladen änderbar

Schnittstellendefinition

Schnittstellen haben keinen Zustand Parameter deshalb nicht erlaubt enthält Methodensignaturen können Methoden implementieren können andere Schnittstellen erweitern

trait TraitDemo { def abstractMethod(x: any): unit; def concreteMethod(x: any): String = x.toString();}

mixin-composition

Unter geeigneten Umständen kann eine Klasse auch die nur die neuen Methoden erben

Die Klasse mit den neuen Methoden heißt mixin

Funktioniert nur, wenn die Oberklasse des mixins eine Oberklasse der Oberklasse der zu erweiternden Klasse ist

mixin-Beispielclass Point(xc: int) { val x = xc; override def toString() = “x= “ + x;}class ColoredPoint(u: int, c: String) extends Point(u) { var color = c; override def toString() = super.toString() + “, c= “ + c;}class Point2D(xc:int, yc: int) extends Point(xc) { val y = yc; override def toString() = super.toString() + “, y= “ + y; }

class ColoredPoint2D(xc: int, yc: int, c: String) extends Point2D(xc, yc) with ColoredPoint(xc, c);}

generische Klassen

Objekttyp wird als Parameter in eckigen Klammern übergeben

Parametername kann nun wie ein Typbezeichner verwendet werden

class generischesBeispiel[a](xc: a) { val x: a = xc;}

[...] (args: Array[String]) [...]

type-bounds

können Typ-Parameter einschränken lower-type-bound: Typ-Parameter T muss

Oberklasse eines anderen Typs A seinT >: A

upper-type-bound: Typ-Parameter T muss eine definierte Oberklasse A haben

T <: A

Funktionen

Parameter polymorphe Funktionen Currying anonyme Funktionen Operatoren

Parameter

Übergabe erfolgt in Parameterlisten Typangabe nach Typbezeichner Anzahl der Parameterlisten beliebig Funktionen selbst als Parameter möglich

„Funktionen höherer Ordnung“

def fktBsp(a: int, b: String): unit = { [...]}

def fktBsp2(f: int => String, v: int): String = { f(v);}

Polymorphe Funktionen

sind generische Methoden lassen sich mit Typ-Parameter versehen lassen sich mit type-bounds einschränken kein Bruch zwischen Klassen und

Funktionen

def polyBsp[T](x: T, n: Int): List[T] = { [...]}

Currying

Angabe mehrerer Parameterlisten erlaubt allgemeinere Methoden

Aufruf übergibt Parameterlisten und liefert eine Referenz auf eine „konfigurierte“ Methode

def modN(n: Int)(x: Int): Boolean = { ((x % n) == 0);}

modN(2)

def modN(x: Int): Boolean = { ((x % 2) == 0);}

Anonyme Funktionen

ermöglichen Methodendefinition ohne Bezeichner

Sinnvoll bei Aufruf an einer Stelle im Code implizite Definition erfolgt durch Compiler Parameter-Rumpf-Trennung durch =>

(x: int, y: int) => x * y

Operatoren

Operatoren sind ebenfalls Objekte Genauer: eine abkürzende Schreibweise Formaler: Methoden, die einen Parameter

erwarten, in einer Infix-Notation

b = a + 3; b = a.+(3);

Framework-Integration

Nahtlose Interaktion mit der JRE oder der CLR war ein Entwicklungsziel

Scala derzeit ein Wrapper für JVM und Java Compiler

java.lang.* ist bereits importiert Compile-Ergebnis ist Bytecode

Fortgeschrittene Konzepte

Local Type Inference Pattern-Matching Regular Expression Patterns Case-Classes native XML-Unterstützung Sequence Comprehensionsfor (val i: int <- Iterator.region(0, 23)) { [...]}

for (val i: int <- Iterator.region(0, 23); i % 2 == 0) { [...]}

Beispiel-Anwendung: QuickSort

Scala-Implementierung OO und funktional Funktionale Implementierung vertauscht

nicht, sondern filtertdef sort(a: List[int]): List[int] = { if (a.length < 2) { a } else { val pivot = a(a.length / 2); sort(a.filter(x => x < pivot)) ::: a.filter(x => x == pivot) ::: sort(a.filter(x => x > pivot)); }}

QuickSort in Java

Java-Code im Wesentlichen durch„Schlüsselwort-Transformation“

def swap(i: int, j: int): unit = { val t = a(i); a(i) = a(j); a(j) = t;}

private static void swap(int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t;}

Benchmark-Ergebnisse

0

1

2

3

4

5

6

100.000 1.000.000 10.000.000 100.000.000

Java Scala OO Scala Fkt

Zusammenfassung

Einige Interessante Möglichkeiten Mainstream-Features der nahen Zukunft Gute Integration Schnell genug für den täglichen Einsatz Scala ist noch nicht fertig

Abschließend ...

Scala (ital. Treppe) ist vielleicht nicht DER nächste Schritt, aber ein Schritt in die

richtige Richtung

Vielen Dank für Ihre Aufmerksamkeit.