SCALA: ein kurzer Überblick

S CALA: ein kurzer Überblick
JUGHRO-Treffen November 2011

Roland Ewald
Institut für Informatik, Universität Rostock

16. November 2011 c 2011 UNIVERSITÄT ROSTOCK | FAKULTÄT FÜR INFORMATIK UND ELEKTROTECHNIK 1

Disclaimer

• Ich bin ein S CALA-Anfänger

• Übergang schrittweise &
punktuell

• No Silver Bullet

Image source: user whatnot, http://www.flickr.com/photos/whatnot/6853556/

Überblick

Warum Scala?

Snippets & Grundkonzepte

Beispiel: Rationale Zahlen

Praxis

Zusammenfassung


Warum

• Interessante Sprache :-)

• Nutzt Java als Plattform (JVM)

• ’Kritische Masse’ scheint erreicht (scala-Tag #130 bei stackoverﬂow; noch
vor math, testing, java-ee oder tomcat)

• Ist nicht mehr ’bleeding edge’ (aktuell Version 2.9, entwickelt seit 2003)

• Mehr Gründe auf http://www.scala-lang.org


Motivation
• Scala = Scalable Language

• Soll mit Nutzeranforderungen wachsen

• Skript ⇐⇒ Große Anwendung

• Statisch getypt (wie Java)

• Unterstützt objektorientierte UND funktionale Programmierung

• Weniger Boilerplate (kann Codelänge um 50% – 90% reduzieren)


Material

• Gutes Buch vom Entwickler der Sprache
(Martin Odersky)

• Erste Auﬂage frei verfügbar:
http://www.artima.com/pins1ed/

• Blog-Serie Scala for Java Refugees:
http://www.codecommit.com/blog/scala/
roundup-scala-for-java-refugees


Funktionale Programmierung1

1. Funktionen sind Objekte erster Klasse

2. Funktionen haben keine Seiteneffekte

val meineFunktion = (x:Int, y:Int) => x + y
println(meineFunktion(1,1))

(Ein Welt für sich, Grundidee bereits durch λ-Kalkül von Church entwickelt.
Beliebte funktionale Sprachen: Scheme, Haskell, OCaml, F#)

1 Aus Sicht der Scala-Entwickler :)


Maps, Operatoren & das Factory-Pattern

var capital = Map("US" -> "Washington", "France" -> "Paris")
capital += ("Japan" -> "Tokyo")
println(capital("France"))
Codebeispiel aus Odersky et al., Programming in Scala, 2008

Warum leicht lesbar?
• Typinferenz
• Factory-Methode ’versteckt’
• Sinvolle Operatoren
• Vordeﬁnierte Funktionen


Interoperabilität mit Java / Neue Typen erzeugen

{
import java.math.BigInteger
def factorial(x: BigInteger): BigInteger =
if (x == BigInteger.ZERO)
BigInteger.ONE
else
x.multiply(factorial(x.subtract(BigInteger.ONE)))

println(factorial(BigInteger.TEN))
}

def factorial(x: BigInt): BigInt =
if (x == 0) 1 else x * factorial(x - 1)
println(factorial(10))


Neue Kontrollstrukturen erzeugen2

actor {
var sum = 0
loop {
receive {
case Data(bytes) => sum += hash(bytes)
case GetSum(requester) => requester ! sum
}
}
}

2 Diese hier sind von Erlang geborgt :-)


Weniger Boilerplate (durch ’Properties’)

class MyClass {
private int index;
private String name;

public MyClass(int index, String name) {
this.index = index;
this.name = name;
}
}

class MyClass(index: Int, name: String)


Weniger Boilerplate (durch funktionale
Programmierung)

boolean nameHasUpperCase = false;
for (int i = 0; i < name.length(); ++i) {
if (Character.isUpperCase(name.charAt(i))) {
nameHasUpperCase = true;
break;
}
}

val nameHasUpperCase
= name.exists(_.isUpperCase)


Weniger Boilerplate (durch Support für n-Tupel)3

//In James II wäre das:
import james.core.util.misc.Pair;
//...
Pair<Integer,String> pair = new
Pair<Integer,String>(99,"Luftballons");
System.out.println(pair.getFirstValue());
System.out.println(pair.getSecondValue());

var pair = (99, "Luftballons")
println(pair._1)
println(pair._2)

3 ∀n ≤ 22


Grundideen

Funktionen...
• geben immer etwas zurück (zumindest Unit)
• können teilweise deﬁniert werden (⇒ Currying/Closures)
• werden genauso behandelt wie Werte (⇒Werte sind konstante Funktionen)4
• können lokale Funktionen enthalten
• können echt seltsame Namen haben, z.B. +, +=, ::, /
• können unterschiedlich aufgerufen werden

4 Konvention: myObject.x hat keine Seiteneffekte, myObject.x() schon


Aufruf von Funktionen

class MeineKlasse {
def verdoppeln(x: Int) = 2 * x
def <<(x: Int) = verdoppeln(x)
}

val meinObjekt = new MeineKlasse()
println(meinObjekt.verdoppeln(2))
println(meinObjekt.<<(2))
println(meinObjekt verdoppeln 2)
println(meinObjekt << 2)


Aufruf von Funktionen

def main(args: Array[String]) {
args.foreach((arg: String) => println(arg))
args.foreach(arg => println(arg))
args.foreach(println(_))
args.foreach(println)
}


Grundideen

• Mehrere public Klassen pro Datei erlaubt.
• Keine primitiven Datentypen mehr (1.toString ist OK)
• Imports haben einen Gültigkeitsbereich
• Sichtbarkeit kann sehr feingranular eingestellt werden
(z.B. protected[my.package], private[this])
• Objects sind Singletons
(und enthalten alle statischen Methoden, static gibt es also nicht)
• Implizite Typumwandlungen
• case classes für Pattern Matching


Was ist (fast) gleich?

• Grundlegende Organisation des Codes (Pakete + Klassen)

• Kontrollstrukturen wie for, while, if etc.
(teilw. mächtiger, z.B. switch ⇒ match)

• Klassenbibliothek (Collections etc.)

• Speicherverwaltung (new wird jedoch weniger benutzt, wegen Companion
Objects und FP)

• Fehlerbehandlung (Exceptions)


Jetzt mal ein konkretes Beispiel...


Rationale Zahlen

n
Sind Zahlen der Form d mit n ∈ Z, d ∈ N ("‘Brüche"’)
...bauen wir also eine Klasse:

class Rational(n: Int, d: Int)

Mit verständlicher Ausgabe und Kontrolle der Eingabe:

class Rational(n: Int, d: Int) {
require(d != 0)
override def toString = n +"/"+ d
}


Hinzufügen der Addition5

require(d != 0)
val numer: Int = n
val denom: Int = d
override def toString = numer +"/"+ denom
def add(that: Rational): Rational =
new Rational(
numer * that.denom + that.numer * denom,
denom * that.denom
)
}

5 Geht eleganter, wird gleich noch ausgebaut...


Hilfskonstruktor für n
1
require(d != 0)
val numer: Int = n
val denom: Int = d

def this(n: Int) = this(n, 1)

override def toString = numer +"/"+ denom

new Rational(
denom * that.denom
)
}


GGT zur Vereinfachung des Bruchs
private val g = gcd(n.abs, d.abs)
val numer = n / g
val denom = d / g

new Rational(
denom * that.denom
)

private def gcd(a: Int, b: Int): Int =
if (b == 0) a else gcd(b, a % b)

//...
}


’Operatoren’
//...
def + (that: Rational): Rational =
new Rational(
denom * that.denom
)

def * (that: Rational): Rational =
new Rational(numer * that.numer, denom * that.denom)

def <(that: Rational) = this.num * that.denom <
this.denom * that.num

//... usw.
}


Unäre ’Operatoren’ und Backticks

//...
def unary_~() = new Rational(denom, num)

def unary_-() = new Rational(-num, denom)

//Sowas hier geht auch:
def `ha<ll$>$%o !`: Int = 2
//... usw.
}


’Operatoren’ für andere Typen

//...

def + (i: Int): Rational =
new Rational(numer + i * denom, denom)

//... usw.
}


Implizite Typumwandlung
class Rational(n: Int, d: Int)//...
object TestRationals {
implicit def intToRational(x: Int) = new Rational(x)

def main(args: Array[String]) {
val oneHalf = new Rational(1, 2)
val twoThirds = new Rational(20, 30)
println(oneHalf + twoThirds)
println(oneHalf < twoThirds)
println(new Rational(3))
println(~oneHalf)
println(oneHalf * 5 - oneHalf)
println(5 * oneHalf)
}
}


Vorsicht! "‘[...]creating methods with operator names and
deﬁning implicit conversions can help you design
libraries for which client code is concise and easy to
understand. Scala gives you a great deal of power
to design such easy-to-use libraries, but please
bear in mind that with power comes
responsibility. [...]
Conciseness will often be a big part of that
readability, but you can take conciseness too far. By
designing libraries that enable tastefully
concise and at the same time
understandable client code, you can help
those client programmers work productively."’
(p. 113, Odersky et al., Programming in Scala, 2.
Ausgabe)

Image source: user mostuncool, http://www.flickr.com/photos/mostuncool/102762603/


’Pimp-My-Library’ Pattern
import java.io._
import scala.io._

class RichFile(file: File ) {

def text = Source.fromFile( file ).mkString

def text_=( s: String ) {
val out = new PrintWriter( file )
try{ out.println( s ) }
finally{ out.close }
}
}

object RichFile {
implicit def enrichFile( file: File ) = new RichFile( file )
}

//...
val f = new File("/tmp/example.txt")
f.text = "hello world"
Von: http://stackoverflow.com/questions/6879427/scala-write-string-to-file-in-one-statement


Praxis


Tools

• Eclipse-Integration: http://www.scala-ide.org
• Test-Frameworks: JUnit etc. (Bytecode-kompatibel)
• S CALA-Konsole
• Interessante Frameworks, z.B. L IFT (http://liftweb.net/)


Maven-Integration6

<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-compiler</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>2.9.0</version>
</dependency> 
<build>
<sourceDirectory>src/main/scala</sourceDirectory>
<testSourceDirectory>src/test/scala</testSourceDirectory>
<plugins>
<plugin>
<groupId>org.scala-tools</groupId>
<artifactId>maven-scala-plugin</artifactId>
</plugin> 

6 Benötigt Repository http://scala-tools.org/repo-releases

Scripting
#!/bin/sh
exec scala "$0" "$@"
!#
import java.io._
import scala.collection.mutable.Set

if(args.size < 2) {
println("Usage: addAccess hgrc_file user1 [user2 ...]")
sys.exit(0)
}

val singleLines = io.Source.fromFile(args(0)).mkString.split("n")
val editedLines = singleLines.map(l => if(matches(l)) update(l) else l)
val out = new PrintWriter(new File(args(0)))
try{ out.println(editedLines.mkString("n")) } finally{ out.close }

def matches(line:String) = line.matches(".*allow_(read|push).*=.*")
def update(line:String) = {
val splitLine = line.split("=")
val elems = Set() ++ splitLine(1).split(",").map(_.trim) ++ args.toList.tail
splitLine(0).trim + " = " + elems.mkString(", ")}


Zusammenfassung


Zusammenfassung

• Scala ist JVM-kompatibel

• Scala ’wächst’ mit den Aufgaben

• Scala ist ideal, um als Java-Programmierer FP zu lernen/anzuwenden

• Scala bietet Java gegenüber viele kleine Verbesserungen, kann also auch
ohne FP-Ambitionen genutzt werden


Interessante Features die es nicht in den Überblick
geschafft haben

• Actors (einfache nebenläuﬁge Programmierung)
• Traits (Interfaces mit Logik!)
• Pattern Matching
• Annotationen
• Arrays
• DSLs bauen (siehe Actors)
• Unterstützung von XML & Regex


Alternativen

Java ohne Boilerplate: http://www.eclipse.org/Xtext/xtend

’Echte’ funktionale Programmierung auf der JVM: http://clojure.org

Scala in einfach:
http://confluence.jetbrains.net/display/Kotlin


Material zum Weitermachen
• The busy Java developer’s guide to Scala:
http://www.ibm.com/developerworks/java/library/
j-scala01228

• Programming Scala:
http://ofps.oreilly.com/titles/9780596155957/

• Scala School:
http://twitter.github.com/scala_school/

• 99 Scala Problems:
http://aperiodic.net/phil/scala/s-99/


Lizenzen

• Bilder von Folie #2 & #28: Creative Commons BY-NC-SA 2.0
• Alle eigenen Inhalte ebenso

Siehe: http://creativecommons.org/licenses/by-nc-sa/2.0/deed.de


SCALA: ein kurzer Überblick

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie SCALA: ein kurzer Überblick

Ähnlich wie SCALA: ein kurzer Überblick (20)

SCALA: ein kurzer Überblick