Introduktion till SML Nr 2

1. Introduktion till SMLNr 2 Värden, typer och funktioner

2. Några begrepp interaktiv frågor och svar växelvis mellan dator och användare prompt Visas när systemet är beredd att ta emot kommandon operator En symbol för en funktion med två argument t ex +

3. SML program • Funktionsdefinitioner • Värdesdefinitioner • Uttryck • Dessutom • Typdefinitioner • Undantagsdefinitioner • Moduler • etc

4. Värden, uttryck och typer • Typen beskriver en grupp värden. • Varje värde har en och endast en typ. • En typ kan vara sammansatt av flera andra typer. • Uttrycken beräknas till värden.

5. Interaktivt • SML är ett interaktivt system. - 34 + 45; > val it = 79 : int • Givet ett uttryck eller en definition beräknar systemet dess värde och typ. • Alla uttryck vid prompten avslutas med semicolon • SML skiljer på stora och små bokstäver,Thunk , THUNK och thunk är olika namn.

6. Grundläggande typer • Booleska - true;> true : bool • Heltal - 5;> 5 : int • Reella tal - 34.87;> 34.87 : real • Strängar - "This is a string";> "This is a string" : string

7. Booleska Namn: bool Värden: true, false Operatorer: not, orelse, andalso, if...then...else... Jämföra: =, <> Not: Resultatet från jämförelse operatorerna >, <, >=, <= och likhets operatorerna =, <> är en bool

8. Booleska exempel - not true;> false : bool - true andalso false;> false : bool - (false orelse not false) andalso not (not true);> true : bool

9. Heltal Namn: int Värden: Alla heltal, ... ~3, ~2, ~1, 0, 1, 2, 3, ... Operatorer: +, *, -, ~, div, mod Jämföra: =, <>, >, <, >=, <=

10. Heltal exempel - ~5 + 4;> ~1 : int - (12 + 21) * (2 + 1) - 23;> 76 : int - 24 * 2 = 6 * 4 * 2;> true : bool - 26 div 3 < 26 mod 3;> false : bool

11. Reella tal Namn: real Värden: Alla flyttal (reella) ~2E32…~1.0…~7.8E~3…0.0…3.2E~10…1.0…3.8E43… Operatorer: +, -, *, /, sqrt, sin, … Jämföra: =, <>, >, <, >=, <=

12. Reella tal, exempel - 23.0 * 34.0;> 782.000 : real - 29E23 / (~2E~4 + 22E~1);> 1.31830E+24 : real - 33.02 * 10.0 - 100.0;> 230.200 : real - 34.0 >= sqrt(34.0 * 34.0);> true : bool

13. Numerisk precision • Heltalen har begränsad storlek • Reella talen mycket större eller mindre men ej exakta. • Om tal blir för stora eller för små kan man få fel meddelande.

14. Strängar Namn: string Värden: en sekvens av tecken mellan situationstecken ("), "Hej", "Flera konstiga tecken är möjliga!" Operatorer: ^ (konkatenering, sammanslagning), explode, implode,chr, ord Jämföra: =, <>, >, <, >=, <=

15. Strängar exempel - "Hej "^"Hej!";> "Hej Hej!" : string - size "En lång sträng";> 14 : int - size ("Detta"^" "^ " blir en lååååååååång "^ "sträng");> 34 : int - "AAAA" < "BBBB";> true;

16. Unit Namn: unit Värden: () (unit) Operatorer: Inga Jämföra: =, <> Not: Typen med endast ett värde. Används för funktioner som inte behöver något värde som argument eller för funktioner som inte ger något egentligt värde som resultat.

17. Sammansatta typer • Ett värde av en enkel (grundläggande) typ är odelbart och kan inte delas upp eller separeras. • Ett värde av en sammansatta typ består av flera delar och kan plockas isär.

18. Tuppler • En sekvens av ett bestämt antal mixade typer • Använd för att representera en grupp av egenskaper • (…,….,…,…) - ("Saab",2,true);> ("Saab",2,true) : string * int * bool • Kan även innehålla tuppler - ("Saab",("900",(1980,"jan")),(2,true,65.3));> ("Saab",("900",(1980,"jan")),(2,true,65.3000)) : string * (string * (int * string)) * (int * bool * real)

19. Tuppler, kartesisk produkt • En kartesisk produkt är en sammanslagning av två typer A och B, sammanslagningen bildar en ny typ A * B. • Ett värde i den kartesiska produkten är ett par av två värden sådant att första värde kommer från A och andra värde kommer från B. • Typen A * B är alla sådana par. • Antalet värden som finns i typen är • (antalet värden i A) * (antalet värden i B) • Där av namnet produkt

20. Tuppler, generell form • (uttryck1,uttryck2,…,uttryckn) med typerna:uttryck1 : typ1uttryck2 : typ2...uttryckn : typn • Ger tupeln typen typ1 * typ2 * … * typn

21. Funktionstyp • En funktion har ett antal namngivna abstraktionspunkter. • Dessa kallas formella parametrar eller bundna variabler • En funktion har typen från en domäntyp (typen hos den formella parametern) till ett resultattyp. • Skrivs på formen domäntyp -> resultattyp • När funktionen appliceras på ett värde av domäntypen så beräknas ett värde av resultattypen.

22. Funktionsapplikation • Det värde som funktionen appliceras på kallas argument eller aktuell parameter. • Funktionsapplikation har formen: • uttryck1 uttryck2 • uttryck1beräknas till en funktion • uttryck2beräknas tillvärde av domäntypen • En funktions applikation är ett uttryck i sig. • Vissa funktioner som appliceras på två argument skriv mellan argumenten • uttryck1 operator uttryck2 • Kallas infix operatorer

23. Funktionskomposition • En funktion tar ett funktionsanrop som argument. - sin (sqrt 3.14)> 0.979826 : real sin (sqrt 3.14) ==>sin 1.772 ==> 0.979826 • Infixa operatorn o används för funktionskomposition - (sin o sqrt o cos) 0.14;> 0.838811 : real • (f1 o f2) x = f1 (f2 x)

24. Egenskaper hos operatorer • Om det finns flera sätt att beräkna ett uttryck så är det egenskaperna prioritet och associativitet hos operatorerna som avgör i vilken ordning de ska beräknas. 3 + 4 * 5 / 2 Tolkas som 3 + ((4 * 5)/ 2)

25. Prioritet • Operatorer har olika prioritet, ju högre prioritet desto starkare binder operatorn.* har högre prioritet än +. • Det medför att • 3 + 4 * 5 • tolkas som • 3 + (4 * 5).

26. Prioritetsordningen Högst (…) Funktionsanrop, ~ * / div mod + ^ :: @ = <> < > <= >= o Lägst

27. Associativitet • Ifall det är samma operator eller de har samma prioritet så avgör associativiteten. • Dvs vilket håll som går före. • Nästan alla operatorer är vänster associativa. • Det medför att • 3 + 4 + 5 • tolkas som • (3 + 4) + 5

28. Kommutativitet • Om en operator är kommutativ så spelar det ingen roll vilken ordning det är på argumenten. • + är kommutativ. • Det medför att • 3 + 4 = 4 + 3. • / är inte kommutativ, • 3 / 4¹4 / 3.

29. Överlagring • Vissa symboler står för flera operatorer. • +, - och * är definierade för både heltals- och flyttalspar. • ~ är definierad för både heltal och flyttal. • Samma symbol används för flera funktioner.

30. Villkorsuttryck Beräknar inte mer än nödvändigt • Andalso uttryck1andalso uttryck2 • Om första är falskt blir allt falskt annars blir det som andra uttrycket • Orelse uttryck1orelseuttryck2 • Om första uttrycket är sant så är hela uttrycket sant annars som andra uttrycket. • If .. then .. else ifvillkorthen om_santelse om_falskt • om villkoret är sant är värdet det första uttrycket annars det andra

31. Kommentarer • Kommentarer skriv mellan (* och *) och ignoreras av systemet. - (* detta är en kommentar *) 45; > 45 : int

32. Globala deklarationer • För att ge namn åt ett värde - valnamn = uttryck; • Systemet evaluerar uttrycket till ett värdet val av typen type och associerar namnet med det värdet. > valname = val : type • Namnet kan sedan användas istället för värdet överallt i resten av programmet.

33. Exempel - val pay = 12000; > val pay = 12000 : int - val name = ("Mats","Ek"); > val name = ("Mats","Ek") : string * string - pay; > 12000 : int - name; > ("Mats","Ek") : string * string - val tax = pay * 33 div 100; > val tax = 3960 : int - val payslip = (name,pay,tax,pay-tax); > val payslip = (("Mats","Ek"),12000,3960,8040) : (string * string) * int * int * int

34. Special namn • Reserverade ord • Specialbehandlas av ML, kan ej användas till annat. • Fet stil i exempel. fn fun andalso orelse if then else val … • Fördefinierade ord • Redan definierade funktioner och värden, kan, men bör ej, användas. sin cos real floor + - …

35. Funktioner • Funktioner är abstraktioner över uttryck. • Den formella parametern ger det namn som används för generaliseringen, namnet används sedan i funktionskroppen. • När en funktion anropas med ett argument beräknas funktionskroppen med den formella parametern ersatt av värdet av argumentet • Att anropa en funktion specialiserar ett abstraherat uttryck

36. Funktionsvärden • Ett funktionsvärde har formen fnname => expression • Motsvarar replacenameinexpression • name är den formella parametern, den bundna variabeln • expression är funktionskroppen

37. Funktionstyp fnname => expression • Om name kan associeras med typen type1 och expression beräknas till ett värde av typen type2 då är funktionens typ type1 -> type2 • Funktionen är en avbildning från type1 till type2 • Exempel - fn sum => sum * 33 div 100; > fn : int -> int

38. Funktionsapplikation • En funktion appliceras (anropas) på ett argument function_expression argument_expresion • Först beräknas function_expression till en funktion fnname => expression med typen type1 -> type2 • Därefter beräknas argument_expression till ett värde value som måste ha typen type1 • Till sist beräknas expression med alla förekomster av name utbytta mot value det ger ett resultat med typen type2.

39. Exempel - (fn sum => sum * 33 div 100) 1000; > 330 : int (fn sum => sum * 33 div 100) 1000 ==> 1000 * 33 div 100 ==> 33000 div 100 ==> 330 - fn word => word^"s"; > fn : string -> string - (fn word => word^"s") ("fish"^"cake"); > "fishcakes" : string (fn word => word^"s") ("fish"^"cake") ==> (fn word => word^"s") ("fishcake") ==> "fishcake"^"s" ==> "fishcakes"

40. Namngivning av funktioner • Globala deklarationer kan ge namn åt funktioner - val name = function; • Då ger systemet namnet och funktionens typ som svar > val name = fn : type

41. Exempel - val tax = fn sum => sum * 33 div 100; > val tax = fn : int -> int - valplural = fnword => word ^ "s"; > val plural = fn : string -> string - tax 1000; > 330 : int - plural ("fish"^"cake"); > "fishcakes" : string

42. Use • Om programmet inte skrivs in direkt vid prompten så kan den lagras i en fil och läsas in till system med kommandot use. - use "myfile.ml"; - use "F:/mittbibl/minfil.ml"; - use "//peppar/olof/mittbib/minfil.ml";