1 Introduktion till SML Nr 2 Värden, typer och funktioner

2 Några begrepp interaktivfrågor och svar växelvis mellan dator och användare promptVisas när systemet är beredd att ta emot kommandon operatorEn 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 ; > 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 ; > : 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 >, =, ä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 - ( ) * (2 + 1) - 23; > 76 : int - 24 * 2 = 6 * 4 * 2; > true : bool - 26 div 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 * 34.0; > : real - 29E23 / (~2E~4 + 22E~1); > E+24 : real * ; > : real >= 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" 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, )) : 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 (uttryck 1,uttryck 2,…,uttryck n ) med typerna: uttryck 1 : typ 1 uttryck 2 : typ 2... uttryck n : typ n Ger tupeln typen typ 1 * typ 2 * … * typ n

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: –uttryck 1 uttryck 2 –uttryck 1 beräknas till en funktion –uttryck 2 beräknas till värde av domäntypen En funktions applikation är ett uttryck i sig. Vissa funktioner som appliceras på två argument skriv mellan argumenten –uttryck 1 operator uttryck 2 –Kallas infix operatorer

23 Funktionskomposition En funktion tar ett funktionsanrop som argument. - sin (sqrt 3.14) > : real sin (sqrt 3.14) ==> sin ==> Infixa operatorn o används för funktionskomposition - (sin o sqrt o cos) 0.14; > : real (f 1 o f 2 ) x = f 1 (f 2 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 * 5 / 2 Tolkas som3 + ((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 – 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 = / ä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 uttryck 1 andalso uttryck 2 –Om första är falskt blir allt falskt annars blir det som andra uttrycket Orelse uttryck 1 orelse uttryck 2 –Om första uttrycket är sant så är hela uttrycket sant annars som andra uttrycket. If.. then.. else if villkor then om_sant else 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 - val namn = uttryck; Systemet evaluerar uttrycket till ett värdet val av typen type och associerar namnet med det värdet. > val name = 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 = : int - val name = ("Mats","Ek"); > val name = ("Mats","Ek") : string * string - pay; > : 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 fn name => expression Motsvarar replace name in expression name är den formella parametern, den bundna variabeln expression är funktionskroppen

37 Funktionstyp fn name => expression Om name kan associeras med typen type 1 och expression beräknas till ett värde av typen type 2 då är funktionens typ type 1 -> type 2 Funktionen är en avbildning från type 1 till type 2 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 fn name => expression med typen type 1 -> type 2 Därefter beräknas argument_expression till ett värde value som måste ha typen type 1 Till sist beräknas expression med alla förekomster av name utbytta mot value det ger ett resultat med typen type 2.

39 Exempel - (fn sum => sum * 33 div 100) 1000; > 330 : int (fn sum => sum * 33 div 100) 1000 ==> 1000 * 33 div 100 ==> div 100 ==> 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 - val plural = fn word => 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";