Przygotował: Jacek Sroka. JNP 3 język Scala

Transkrypt

1 1 JNP 3 język Scala

2 2 Czemu Scala? Język wzorowany na Javie i Haskelu nowoczesny obiektowy język programowania jednocześnie język funkcyjny Programy uruchamiają się na JVM można swobodnie odwoływać się do istniejącego kodu i bibliotek Javy Silnie typowany ciekawy system typów Zwięzła składnia i silniejsza abstrakcja = prostsze programy = mniej błędów Zaprojektowany do wyrażania powszechnych wzorców projektowych Robi się trendy?

3 3 Pierwszy przykład object HelloWorld { def main(args: Array[String]) { println("hello, world!") > scalac HelloWorld.scala > scala -classpath. HelloWorld Hello, world! main() jest procedurą object deklaruje Singleton (klasa i egzemplarz) Nie ma potrzeby dla składowych statycznych

4 4 Jak uruchamiać - shell > scala This is a Scala shell. Type in expressions to have them evaluated. Type :help for more information. scala> object HelloWorld { def main(args: Array[String]) { println("hello, world!") defined module HelloWorld scala> HelloWorld.main(null) Hello, world! scala>:q

5 5 Jak uruchamiać - skrypt #!/bin/sh exec scala "$0" "$@"!# object HelloWorld { def main(args: Array[String]) { println("hello, world! " + args.tolist) HelloWorld.main(args) >./script.sh

6 6 Jak uruchamiać - kompilacja Kompilacja do bytecodu Javy > scalac HelloWorld.scala lub > scalac -d classes HelloWorld.scala Uruchamianie > scala HelloWorld lub > scala -classpath classes HelloWorld argumentem powinien być obiekt najwyższego poziomu jeżeli występuje klauzula extends Application to wykonywane są wszystkie polecenia object HelloWorld2 extends Application { println("hello, world!") wpp wykonywana jest metoda main

7 7 Wygodniejsze importy import java.util.{date, Locale import java.text.dateformat import java.text.dateformat._ Zwięzłe importowanie wielu klas z pakietu _ zamiast * object FrenchDate { def main(args: Array[String]) { val now = new Date val df = getdateinstance(long,locale.france) println(df format now) Trochę inne niż w javie importowanie składowych statycznych Funkcyjna składnia wywoływania metod i przekazywania parametrów Domyślnie importowane jest całe java.lang

8 8 Wszystko jest obiektem Włącznie z liczbami i funkcjami * 3 / x (1).+(((2).*(3))./(x)) 1.+(2) (1).+(2) //żeby lexer nie wybrał najdłuższego dopasowanie dla identyfikatorów

9 Funkcje też są obiektami object Timer { def oncepersecond(callback: () => Unit) { while (true) { callback(); Thread sleep 1000 def timeflies() { println("time flies like an arrow...") def main(args: Array[String]) { oncepersecond(timeflies) object TimerAnonymous { def oncepersecond(callback: () => Unit) { while (true) { callback(); Thread sleep 1000 Możemy przekazywać funkcje jako parametry () => Unit to typ wszystkich funkcji bez argumentów i bez wartości zwrotnej Do wypisywanie użyliśmy predefiniowanej metody println() zamiast System.out Często wygodnie jest używać funkcji anonimowych def main(args: Array[String]) { OncePerSecond(() => println("time flies like an arrow...")) 9

10 10 Klasy class Complex(real: Double, imag: Double) { def re() = real def im() = imag object ComplexNumbers { def main(args: Array[String]) { val c = new Complex(1.2, 3.4) println("imaginary part: " + c.im()) class Complex(real: Double, imag: Double) { def re = real def im = imag Klasy w Scali mają parametry new Complex(1.5, 2.3) Typy zwrotne metod zazwyczaj mogą być wywnioskowane przez kompilator Wywołując metody z zerową liczbą argumentów trzeba wstawiać puste nawiasy Metody można zdefiniować jako bezparametrowe Domyślną nadklasą jest scala.anyref class Complex(real: Double, imag: Double) { Przedefiniowując metody trzeba to def re = real jawnie wskazać def im = imag override def tostring() = "" + re + (if (im < 0) "" else "+") + im + "i"

11 11 Warianty i dopasowywanie abstract class Tree case class Sum(l: Tree, r: Tree) extends Tree case class Var(n: String) extends Tree case class Const(v: Int) extends Tree //taką funkcją możemy //reprezentować środowisko //dla "x" zwraca 5 wpp wyjątek { case "x" => 5 //alias dla typu type Environment = String => Int Wsparcie do reprezentacji drzew, np. XML Przykład: kalkulator z sumowaniem, stałymi całkowitymi i zmiennymi Const(5) zamiast new Const(5) Automatycznie są gettery np. dla c egzemplarza Const mamy c.v equals i hashcode działają na strukturze tostring wypisuje "literał np. Sum(Var(x,Const(1))) Można dopasowywać do wzorca

12 12 Warianty i dopasowywanie c.d. def eval(t: Tree, env: Environment): Int = t match { case Sum(l, r) => eval(l, env) + eval(r, env) case Var(n) => env(n) case Const(v) => v //jak nic się nie dopasuje to wyjątek def derive(t: Tree, v: String): Tree = t match { case Sum(l, r) => Sum(derive(l, v), derive(r, v)) case Var(n) if (v == n) => Const(1) //dopasowanie warunkowe case _ => Const(0) //guard def main(args: Array[String]) { val exp: Tree = Sum(Sum(Var("x"),Var("x")),Sum(Const(7),Var("y"))) val env: Environment = { case "x" => 5 case "y" => 7 println("expression: " + exp) //Expression: Sum(Sum(Var(x),Var(x)),Sum(Const(7),Var(y))) println("evaluation with =5, y=7: " + eval(exp, env)) //Evaluation with x=5, y=7: 24 println("derivative relative to x: " + derive(exp, "x")) //...to x: Sum(Sum(Const(1),Const(1)),Sum(Const(0),Const(0))) println("derivative relative to y: " + derive(exp, "y")) //..to y: Sum(Sum(Const(0),Const(0)),Sum(Const(0),Const(1)))

13 13 Dopasowywanie wzorców vs polimorfizm Przy pomocy dopasowywania wzorców bardzo łatwo dodać nową metodę dla całej hierarchii. Dużo roboty jak nowy węzeł. Za pomocą polimorfizmu łatwo dodać nowy rodzaj węzła. Dużo roboty jak nowa metoda.

14 14 Traits trait Ord { def < (that: Any): Boolean def <=(that: Any): Boolean = (this < that) (this == that) def > (that: Any): Boolean =!(this <= that) def >=(that: Any): Boolean =!(this < that) Wzbogacanie klasy (interfejs z implementacją) Any to bardziej ogólny Object

15 15 Traits c.d. class Date(y: Int, m: Int, d: Int) extends Ord { def year = y; def month = m def day = d override def tostring(): String = year + "" + month + "" + day override def equals(that: Any): Boolean = that.isinstanceof[date] && { val o = that.asinstanceof[date] o.day == day && o.month == month && o.year == year def <(that: Any): Boolean = { if (!that.isinstanceof[date]) error("cannot compare " + that + " and a Date") val o = that.asinstanceof[date] (year < o.year) (year == o.year && (month < o.month (month == o.month && day < o.day)))

16 16 Generyki class Reference[T] { private var contents: T = _ def set(value: T) { contents = value def get: T = contents Parametryzowanie kodu typami Piszemy ogólny kod i nie musimy bez przerwy rzutować "_ to wartość domyślna dla zmiennej object IntegerReference { def main(args: Array[String]) { val cell = new [Int] cell.set(13) println("reference contains the half of " + (cell.get * 2))

17 17 Quicksort def sort(a: Array[Int]) { def swap(i: Int, j: Int) { val t = a(i); a(i) = a(j); a(j) = t def sort1(l: Int, r: Int) { val pivot = a((l + r) / 2) var i = l var j = r while (i <= j) { while (a(i) < pivot) i += 1 while (a(j) > pivot) j -= 1 if (i <= j) { swap(i, j) i += 1 j -= 1 if (l < j) sort1(l, j) if (j < r) sort1(i, r) deklaracje zaczynają się zarezerwowanym słowem: def, var, val typ podajemy po symbolu i : jak się da to kompilator domyśli się typu i nie trzeba go podawać Array[Int] zamiast Int[] a(i) zamiast a[i] zagnieżdżone funkcje mają dostęp do parametrów i zmiennych if (a.length > 0) sort1(0, a.length - 1)

18 18 Quicksort c.d. object sort { def sort(a: Array[Int]) { //... def println(ar: Array[Int]) { def print1 = { def iter(i: Int): String = ar(i) + (if (i < ar.length-1) "," + iter(i+1) else "") if (ar.length == 0) "" else iter(0) Console.println("[" + print1 + "]") def main(args: Array[String]) { val ar = Array(6, 2, 8, 5, 1) println(ar) sort(ar) println(ar)

19 19 Quicksort wersja funkcyjna def sort(a: Array[Int]): Array[Int] = { if (a.length < 2) a else { val pivot = a(a.length / 2) Array.concat(sort(a.filter(x => x < pivot)), a.filter(x => x == pivot), sort(a.filter(x => x > pivot))) Obiekty Array[T] mają metodę (pochodzącą z klasy Seq[T]) def filter(p: T -> Boolean): Array[T] Można użyć składni a.filter(_ < pivot) a nawet (partially applied function) a.filter(pivot >) Operatory przekładają się na wywołania metod: a filter (pivot >) Dla podstawowych operatorów kompilator powinien generować dobry kod Ponieważ ciało funkcji jest wyrażeniem można pominąć {

20 20 Dyskusja zapotrzebowanie na pamięć wielowątkowość

21 21 Funkcje wyższego rzędu def While (p: => Boolean) (s: => Unit) { if (p) {s; While(p)(s) tak naprawdę jest specjalna konstrukcja oba parametry są bezparametrowe Unit to tak jakby void jak nie zwracamy żadnego wyniku to tak jak byśmy zwracali () nie trzeba podawać return, domyślnie wynikiem funkcji jest wynik ostatniego wyrażenia

22 22 Wyrażenia scala> res0: Int = 232 scala> 5+2*3 res1: Int = 11 scala> "hello"+" world!" res2: java.lang.string = hello world! scala> def pi = pi: Double scala> def radius = 10 radius: Int scala> 2*pi*radius res7: Double =

23 23 Kiedy jest wyliczana wartość? wyrażenie w def x = e jest wyliczane dopiero jak jest potrzebne wyrażenie w val x = e jest wyliczane w chwili deklaracji zazwyczaj wyrażenia wyliczane są od lewej (redukcja) (2*pi)*radius (2* )*radius *radius *

24 24 Proste funkcje scala> def square(x: Double) = x*x square: (Double)Double scala> square(2) res11: Double = 4.0 scala> square(5+3) res12: Double = 64.0 scala> square(square(4)) res13: Double = scala> def sumofsquares(x: Double, y: Double) = square(x)+square(y) sumofsquares: (Double,Double)Double scala> sumofsquares(3,2+2) res14: Double = 25.0

25 Wyliczanie wartość funkcji call-by-value sumofsquares(3, 2+2) sumofsquares(3, 4) square(3)+square(4) 3*3+square(4) 9+square(4) 9+4* call-by-name sumofsquares(3, 2+2) square(3)+square(2+2) 3*3+square(2+2) 9+square(2+2) 9+(2+2)*(2+2) 9+4* Dla czystych funkcji zawsze ten sam wynik call-by-value nie powtarza wyliczania argumentów Zazwyczaj bardziej wydajny call-by-name nie wylicza nieużywanych (niepotrzebnych) argumentów 25

26 26 Wyliczanie wartości funkcji c.d. call-by-value łatwiej zapętlić scala> def loop: Int = loop loop: Int scala> def first(x: Int, y: Int) = x first: (Int,Int)Int scala> first(1,loop) call-by-name można wymusić scala> def constone(x:int, y: => Int) = 1 constone: (Int,=> Int)Int scala> constone(1,loop) res2: Int = 1 scala> constone(loop,1)//pętla

27 27 If-else Jak w Javie, ale w Scali jest również wyrażeniem (jak Javowy operator ternarny...?... :...) scala> def abs(x: Double) = if (x >= 0) x else -x abs: (Double)Double Stałe logiczne i operatory są takie same jak w Javie

28 28 Metoda Newtona y x/y (y+x/y)/2 1 2/1 = /1.5 = / =

29 29 Przykład rozwiązania def sqrt(x: Double) = sqrtiter(1.0, x) def sqrtiter(guess: Double, x: Double): Double = if (isgoodenough(guess, x)) guess else sqrtiter(improve(guess, x), x) def improve(guess: Double, x: Double) = (guess + x/guesss)/2 def isgoodenough(guess: Double, x: Double) = abs(square(guess) x) < 0.001

30 Zagnieżdżanie funkcji pomocniczych def sqrt(x: Double) = { def sqrtiter(guess: Double, x: Double): Double = if (isgoodenough(guess, x)) guess else sqrtiter(improve(guess, x), x) def improve(guess: Double, x: Double) = (guess + x/guesss)/2 def isgoodenough(guess: Double, x: Double) = abs(square(guess) x) < sqrtiter(1.0, x) //bloki w Scali są wyrażeniami o wartości kończącego wyrażenia 30

31 31 Standardowa widoczność w zagnieżdżonych blokach def sqrt(x: Double) = { def sqrtiter(guess: Double): Double = if (isgoodenough(guess, x)) guess else sqrtiter(improve(guess, x), x) def improve(guess: Double) = (guess + x/guesss)/2 def isgoodenough(guess: Double) = abs(square(guess) x) < sqrtiter(1.0)

32 32 ; każda definicja w bloku musi się kończyć ; domyślny średnik jest dodawany na końcu każdej linii, chyba że: linia kończy się słowem lub operatorem infiksowym, które nie byłyby dozwolone na końcu wyrażenia następna linia zaczyna się słowem od którego nie mogłoby się zaczynać wyrażenie jesteśmy otoczeni nawiasami def f(x: Int) = x + 1; f(1)+f(2) def g(x: Int) = x + 1 g(1)+g(2) def h(x: Int) = {x+1; h(1)+h(2) //tu średnik jest obowiązkowy

33 33 ; def m(x: Int) = x + y m(1)*m(2) def n(x: Int) = ( x //nawiasy powodują brak średnika + y ) n(1)/n(2)

34 34 Rekursja ogonowa def gcd(a: Int, b: Int): Int = if (b == 0) a else gcd(b, a % b) gcd(14, 21) if (21 == 0) 14 else gcd(21, 14 % 21) if (false) 14 else gcd(21, 14 % 21) gcd(21, 14 % 21) gcd(21, 14) if (14 == 0) 21 else gcd(14, 21 % 14) gcd(14, 21 % 14) gcd(14, 7) if (7 == 0) 14 else gcd(7, 14 % 7) gcd(7, 14 % 7) gcd(7, 0) if (0 == 0) 7 else gcd(0, 7 % 0) 7

35 35 Rekursja ogonowa def factorial(n: Int): Int = if (n == 0) 1 else n * factorial(n-1) factorial(5) if (5 == 0) 1 else 5 * factorial(5 1) 5 * factorial(5 1) 5 * factorial(4) 5 * (4 * factorial(3)) 5 * (4 * (3 * factorial(2))) 5 * (4 * (3 * (2 * factorial(1)))) 5 * (4 * (3 * (2 * (1 * factorial(0)))) 5 * (4 * (3 * (2 * (1 * 1)))) 120