Scala kann auch faul sein

Transkript

1 Scala kann auch faul sein Kapitel 19 des Buches 1

2 Faulheit Faulheit ( lazy evaluation ) ist auch in C oder Java nicht unbekannt int x=0; if(x!=0 && 10/x>3){ System.out.println("In if"); } Nutzen der Faulheit? 2

3 Teure Initialisierung Was könnte am folgenden Code ungeschickt sein? class WebReader(word: String){ import scala.io.source._ val yahoourl = " val wikipediaurl = " } val yahoo = fromurl(yahoourl).mkstring val wikipedia = fromurl(wikipediaurl).mkstring... Antwort: Beide Suchen werden durchgeführt, auch wenn eine oder keine benötigt wird. 3

4 Faule Initialsierung Attribute werden erst dann initialisiert, wenn sie gebraucht werden. lazy val yahoo = fromurl(yahoourl).mkstring lazy val wikipedia = fromurl(wikipediaurl).mkstring 4

5 Call-By-Name Motivation def contains (offline: Boolean, word: String) (text: String) : Boolean = { } if(offline) return true text.contains(word) Beim Aufruf von contains kann das Argument für text sehr teure Operationen enthalten. Wenn das Argument für offline den Wert true hat, ist es aber unnötig, das Argument für text zu berechnen! 5

6 Call-By-Name Nutzung def contains contains(offline=true, word="prog"){ } (offline: Boolean, word: String) (text: =>String) : Boolean = { } if(offline) return true text.contains(word) Bei dieser Definition mittels : => wird text faul ausgewertet, also erst dann, wenn es unbedingt nötig ist. Aufruf: fromurl(" mkstring 6

7 Effizientes Logging umständlich Viele Logging-Frameworks unterscheiden Log-Level. log.debug(message) meldet nur, wenn Level DEBUG. log.debug("at " + ) if(log.isdebugenabled) log.debug("at " + ) DateFormat.getTimeInstance().format(new Date) + ": i=" + i Wenn Log-Level < DEBUG gibt log.debug nichts aus. Dennoch unnötige Objekterzeugung für message Umständlicher Stil mit Log4J: DateFormat.getTimeInstance().format(new Date) + ": i=" + i 7

8 Effizientes Logging mit Call-by-Name Call-by-Name-Parameter vermeidet Argumentberechnung, wenn er nicht angefordert wird. def debug(message: =>String) = if(isdebugenabled) println(message) Bequemer Stil in Scala möglich: log.debug("at " + DateFormat.getTimeInstance().format(new Date) + ": i=" + i ) 8

9 Faule Listen Listen werden komplett zusammengestellt: val pizza = List("Flour", "Water", "Oil", "Yeast") Warum würde folgender Aufruf nicht funktionieren? pizza.map(_.charat(3)) Streams sind faule Listen, damit geht es: val pizza = Stream("Flour", "Water", "Oil", "Yeast") pizza.map(_.charat(3)) Zur Unterscheidung: Lazy Streams. Definiert in scala.collection.immutable.stream. Der folgende Aufruf scheitert selbst für Streams: pizza.map(_.charat(3))(2) Im Interpreter ausprobieren! 9

10 Der cons-operator Den Pizza-Stream hätten wir auch so definieren können import scala.stream.cons val pizza = cons("flour", cons("water", cons("oil", cons("yeast",stream.empty)))) 10

11 Unendliche Streams Durch Rekursion definierbar. Ein Stream mit unendlich vielen 1en: val ones: Stream[Int] = cons(1, ones) Ein Stream mit den natürlichen Zahlen val nat: Stream[Int] = cons(1, nat.map(_+1)) Benutzung z.b.: nat.take(5).tolist Ergebnis: List(1, 2, 3, 4, 5) 11

12 Die Fibonaccizahlen Beobachtung Anwendung: (0, 1, 1, 2, 3, 5, 8,...) + (1, 1, 2, 3, 5, 8,...) = (1, 2, 3, 5, 8,...) val fib: Stream[Int] = cons(0, cons(1, fib.zip(fib.tail).map(v => v._1+v._2) ) ) 12

13 Alles klar? Das Prinzip der Laziness ist auch in imperativen Sprachen bekannt. Neben dem Call-By-Value bietet Scala mit Call-By-Name auch die Möglichkeit, Argumente an Methoden zu übergeben, deren Wert nicht bereits bei der Übergabe ermittelt wird, sondern erst dann, wenn der Wert gebraucht wird. Attribute einer Klasse können als lazy markiert werden und werden dann möglichst spät initialisiert. Der Typ Stream ist eine listenförmige Datenstruktur, deren Elemente erst initialisiert werden, wenn auf sie zugegriffen wird. Mit Hilfe von Streams können unendliche Datenstrukturen definiert werden. 13