Przygotował: Jacek Sroka. Scala Wprowadzenie

Transkrypt

1 1 Scala Wprowadzenie

2 2 Czemu Scala? Język wzorowany na Javie i Haskelu nowoczesny obiektowy język programowania jednocześnie język funkcyjny progr. obiektowe uzupełnia pozostałe paradygmaty (jest ortogonalne do nich) 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 Udogodnienia do programowania równoległego i rozproszonego Robi się trendy (Spark)?

3 3 Pierwszy przykład object HelloWorld { def main(args: Array[String]) { println("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ć - skrypt #!/bin/sh exec scala "$0" "$@"!# args.foreach(println) >./script.sh #! shebang interpreter directive exec is used to run scala without creation new process. Commands which go right after exec will not be executed!# is simple marker for scala utility (see notes below)

7 7 #! /bin/sh echo Header exec echo!# echo Body $./test.sh Header #! /bin/sh echo Header!# echo Body $./test.sh Header./test.sh: line 4:!#: command not found Body

8 8 exec scala -classpath "lib/lib.1.jar:lib/lib.2.jar" "$0" exec scala -savecompiled "$0" //i zaglądamy do jara o nazwie takiej jak skrypt

9 9 Jak uruchamiać - kompilacja Kompilacja do bytecodu Javy > scalac HelloWorld.scala lub > scalac -d dir_for_classes/jar HelloWorld.scala lub fsc szybki kompilator korzystający z demona 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

10 10 Prezentacja IDE i worksheetów

11 11 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) Zwykły import można użyć do importowania składowych zamiast static w Scali są obiekty (ale Javowe składowe statyczne też można importować) Dopuszczalna funkcyjna składnia wywoływania metod i przekazywania parametrów Domyślnie importowane są całe pakiety java.lang, scala (np. Int, Boolean) oraz składowe obiektu scala.predef (np. scala.predef.assert)

12 12 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

13 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 (ze scala.predef) Często wygodnie jest używać funkcji anonimowych def main(args: Array[String]) { oncepersecond(() => println("time flies like an arrow...")) 13

14 14 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 val xyz = 5 override def tostring() = "" + re + (if (im < 0) "" else "+") + im + "i" Klasy w Scali mają parametry new Complex(1.5, 2.3) Typy zwrotne zazwyczaj mogą być wywnioskowane przez kompilator, ale są dobrą dokumentacją Metody bezparametrowe można zdefiniować jako f()=... oraz f= Ale pierwszą można wywoływać jako f() i f, a drugą tylko jako f Konwencja: jak są efekty uboczne to f()=..., jak nie ma to f= i wtedy może być bezpiecznie zamienione na val Domyślną nadklasą jest scala.anyref Przedefiniowując metody trzeba to jawnie wskazać

15 15 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

16 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))) 16

17 17 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.

18 18 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ą) Nie może mieć parametrów konstruktora Można wmieszać do obiektu wiele różnych implementacji Jak kilka razy ta sama metoda to wygrywa implementacja najbardziej na prawo (np. ciało klasy jest bardzo na prawo) Any to bardziej ogólny Object //przy deklaracji class CollegeStudent extends Student with Worker with Underpaid with Young //przy tworzeniu egzemplarza class CollegeStudent extends Student new CollegeStudent with Worker with Underpaid with NotSoYoungAnymore

19 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 //wynik ostatniej linijki jako return def <(that: Any): Boolean = { if (!that.isinstanceof[date]) sys.error("cannot compare " + that + " and a Date") //zgłasza RuntimeException //w Scali nie ma wyjątków kontrolowanych/nadzorowanych val o = that.asinstanceof[date] (year < o.year) (year == o.year && (month < o.month (month == o.month && day < o.day))) 19

20 20 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 Reference[Int] cell.set(13) println("reference contains the half of " + (cell.get * 2))

21 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 zagadka: gdzie jest błąd w kodzie? if (a.length > 1) sort1(0, a.length - 1) 21

22 22 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)

23 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 >) Inny sposób zapisania tej funkcji to x => pivot > x 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ąć { 23

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

25 25 Ćwiczenie Jaki będzie wynik class Person(val name:string, var age:int) def person = new Person("Kumar",12) person.age = 20 println(person.age)

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

27 27 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 =

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

29 29 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

30 30 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; domyślny (w Scali) call-by-name nie wylicza nieużywanych (niepotrzebnych) argumentów

31 31 Wyliczanie wartości funkcji c.d. call-by-value można 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

32 32 def vs val scala> def x = loop x: Boolean scala> val x = loop //potrzebne Ctrl+c

33 33 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 (leniwie, czyli short circut ) Przez rozpisywanie:!true false!false true true && e e false && e false true e true false e e Ćwiczenie: zdefiniuj if-then-else przez rozpisywanie (dla true i false)

34 34 ćwiczenie Zdefiniuj bez używania && ani and(x, y) == x && y or(x, y) == x y

35 35 ćwiczenie Zdefiniuj bez używania && ani and(x, y) == x && y or(x, y) == x y def and(x:boolean,y: =>Boolean) = if(x) y else false def and(x:boolean,y: =>Boolean) = if(!x) false else y def or(x:boolean,y: =>Boolean) = if(x) true else y def or(x:boolean,y: =>Boolean) = if(!x) y else true

36 36 Metoda Newtona sqrt(x) to y taki że y*y=x, inaczej y=x/y znajdujemy kolejne przybliżenia i uśredniamy y x/y (y+x/y)/2 1 2/1 = /1.5 = / = Inaczej: x_{n+1=x_n f(x_n)/f'(x_n) dla f(x)=x^2-s

37 37 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/guess)/2 def isgoodenough(guess: Double, x: Double) = abs(square(guess) x) < 0.001

38 38 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)

39 39 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)

40 40 ; 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 Przykłady poprawnego kodu: 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

41 41 przykłady c.d. def m(x: Int) = x + y m(1)*m(2) def n(x: Int) = ( x //przez nawiasy tu nie będzie średnika + y //i wyliczy się do x+y, a nie +y ) n(1)/n(2)

42 42 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

43 43 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 Tu i tak liczby całkowite nam się przekręcą, ale w wielu przypadkach warto się starać. podobna do