f2.pdf

Intro Typer Tupler och listor Funktioner Flödeskontroll 

Senaste: 

• Allmänt om kursen 

• Paradigmer 

• Motivation 

Idag: 

• Intro till Haskell 

• Hutton till sid 1–33, 43–47


Funktionell programmering 

Generella egenskaper 

Variabler 

Tilldelning 

Sidoeffekter 

Pekare, referenser 

Garbage collection




Variabler Nej! 

Tilldelning 

Sidoeffekter 


Garbage collection





Tilldelning Nej! 

Sidoeffekter 


Garbage collection






Sidoeffekter Nej! 


Garbage collection







Pekare, referenser Nej! 

Garbage collection







Pekare, referenser Nej! 

Garbage collection Ja!



• Mindre att skriva



• Mindre att skriva 

• Färre buggar




• Färre buggar 

• God modulisering




• Färre buggar 

• God modulisering 

• God kodåtervinning


Haskell: egenskaper 

Strikt funktionellt Inget ”fusk” med tilldelning.



Strikt funktionellt Inget ”fusk” med tilldelning. 

Starkt typsystem Hittar många fel tidigt, stödjer 

kodning.





kodning. 

Typklasser Överlagrade funktioner → 

kodåtervinning, god abstraktion.





kodning. 


kodåtervinning, god abstraktion. 

Lat evaluering Beräkna bara det som behövs.





kodning. 



Lat evaluering Beräkna bara det som behövs. 

Funktioner är ”first class” Uppmuntrar 

abstraktion etc





kodning. 



Lat evaluering Beräkna bara det som behövs. 

Funktioner är ”first class” Uppmuntrar 

abstraktion etc 

Moduler Storskalig programutveckling, goda 

bibliotek.


Haskellsystem 

Hugs98 Etablerat interaktivt interpreterande 

system. Används i labbarna. 

CSC: module add hugs98, starta 

med hugs. 

Tips: Använder GNU Readline.


Haskellsystem 

Hugs98 Etablerat interaktivt interpreterande 

system. Används i labbarna. 

CSC: module add hugs98, starta 

med hugs. 

Tips: Använder GNU Readline. 

Glasgow Haskell Compiler (GHC) Dels 

interaktiv interpretator (ghci), dels 

kompilator. 

Genererar binärer direkt, via GNU C 

eller via C--. 

CSC: module add ghc, starts med 

ghci, kompilera med ghc.


Haskell: grunder 

• Kommentarer på en rad med 

”minus-minus”: -- Viktig fkn




”minus-minus”: -- Viktig fkn 

• Nästlade kommentarer över flera rader: 

{- Bla bla -}






{- Bla bla -} 

• Namn (parametrar, funktioner) börjar med 

gemen. Ex: myAddresses






{- Bla bla -} 


gemen. Ex: myAddresses 

• Värden (symboler) börjar med Versal. Ex: 

True






{- Bla bla -} 




True 

• Funktionsanrop utan parantes. Ex: f (x) 

skrivs f 3.






{- Bla bla -} 




True 

• Funktionsanrop utan parantes. Ex: f (x) 

skrivs f 3. 

• Funktionsdefinition som i matte. Ex: 

f (x) = x + 3 skrivs f x = x + 3


Grundläggande typer 

Bool True, False 

Int 2 31 – 2 31 − 1 

Integer Godtyckligt stora 

Float 32 bitar 

Double 64 bitar 

Char ’a’, ’9’, ’\n’ 

String Lasse"


Hugs> not True 

False 

Hugs> True || False 

True 

Hugs> True && False 

False 

Operationer



False 


True 


False 

Hugs> 5 < 7 

True 

Hugs> not (5 < 7) 

False 

Operationer



False 


True 


False 

Hugs> 5 < 7 

True 

Hugs> not (5 < 7) 

False 

Operationer 

Hugs> ’a’ == ’a’ 

True 

Hugs> ’a’ == ’b’ 

False 

Hugs> ’a’ /= ’a’ 

False



False 


True 


False 

Hugs> 5 < 7 

True 

Hugs> not (5 < 7) 

False 

Operationer 

Hugs> ’a’ == ’a’ 

True 

Hugs> ’a’ == ’b’ 

False 

Hugs> ’a’ /= ’a’ 

False 

Hugs> 1+2*3 

7 

Hugs> (1+2)*3 

9 

Hugs> 3^3 

27


Hugs> 42 / 17 

2.47058823529412


Hugs> 42 / 17 

2.47058823529412 

Hugs> 42 div 17 

ERROR - Cannot infer instance 

*** Instance : Num ((a -> a -> a) -> 

*** Expression : fromInt 42 div 17


Hugs> 42 / 17 

2.47058823529412 




*** Expression : fromInt 42 div 17 

Hugs> div 42 17 

2


Hugs> 42 / 17 

2.47058823529412 






2 

Hugs> 42 ‘div‘ 17 

2


Hugs> 42 / 17 

2.47058823529412 






2 

Hugs> 42 ‘div‘ 17 

2 

Hugs> mod 9 2 + 10 ‘mod‘ 3 

2


Tupler: 

(1,2) 

(’A’, True) 

Tupler 

(17, "Lasse", False, False, (1, 2)) 

Enda kravet: Minst två element.


Tupler: 

(1,2) 

(’A’, True) 

Tupler 

(17, "Lasse", False, False, (1, 2)) 

Enda kravet: Minst två element. 

Funktioner: Hugs> fst (1, 2) 

1 

Hugs> snd (1, 2) 

2


Listor 

[1, 2, 3, 4, 5, 6, 7] 

["Lasse", "Arvestad"] 

[]


Listor 

[1, 2, 3, 4, 5, 6, 7] 


[] 

Cons-operatorn : konstruerar par, kedjade par 

ger listor: 

(1 : (2 : (3 : (4 : []))))


Listor 

[1, 2, 3, 4, 5, 6, 7] 


[] 


ger listor: 

(1 : (2 : (3 : (4 : []))))


Listor 

[1, 2, 3, 4, 5, 6, 7] 


[] 


ger listor: 

(1 : (2 : (3 : (4 : []))))


Listor 

[1, 2, 3, 4, 5, 6, 7] 


[] 


ger listor: 

(1 : (2 : (3 : (4 : [])))) = [1, 2, 3, 4]


Listor 

[1, 2, 3, 4, 5, 6, 7] 


[] 


ger listor: 

(1 : (2 : (3 : (4 : [])))) = [1, 2, 3, 4] 

= 1 : 2 : 3 : 4 : []


Funktioner på listor 

Hugs> null [1,2,3] 

False 

Hugs> null [] 

True 

Hugs> head [1,2,3] 

1 

Hugs> tail [1,2,3] 

[2,3] 

Hugs> 

Se också Appendix B.6 i Hutton!


Strängar är listor 

Hugs> ’L’ : ’a’ : ’s’ : ’s’ : ’e’ : [] 

"Lasse" 

Hugs> head "Lasse’’ 

’L’ 

Hugs> "Lars" ++ "Arvestad" 

"LarsArvestad" 

Hugs> length ("Lars"++"Arvestad") 

12


Funktionstyper 

Exempel: logiskt icke är en funktion 

icke : {True, False} → {True, False}.




I Haskell: 

icke : {True, False} → {True, False}. 

Hugs> :t not 

not :: Bool -> Bool




I Haskell: 


Hugs> :t not 

not :: Bool -> Bool 

Funktion som testar om en bokstav är en siffra: 

isDigit c = c >= ’0’ && c




I Haskell: 


Hugs> :t not 

not :: Bool -> Bool 

Funktion som testar om en bokstav är en siffra: 

isDigit :: Char -> Bool 

isDigit c = c >= ’0’ && c


Förenkla med where 

Herons formel: 

Arean A för en triangel med sidorna a, b, c är 

A = p(p − a)(p − b)(p − c) där 

p = (a + b + c)/2.


Förenkla med where 

Herons formel: 

Arean A för en triangel med sidorna a, b, c är 

A = p(p − a)(p − b)(p − c) där 

p = (a + b + c)/2. 

I Haskell: 

area a, b, c = sqrt (p*(p-a)(p-b)(p-c)) 

where p = (a + b + c) / 2


Uttrycket 

Förenkla med let 

area a, b, c = sqrt (p*(p-a)(p-b)(p-c)) 

where p = (a + b + c) / 2 

Kan ersättas med 

area a, b, c = let p = (a + b + c) / 2 

in sqrt (p*(p-a)(p-b)(p-c))


Mer notation: layout-regeln 

”Syskon-uttryck” står under varandra 

f a b c = a + d + e 

where d = b^3 

e = c^4


Alternering med if 

myDigit c = if c >= ’0’ && c














Alternering med vakter 

I matematik: 

abs(x) = 

 

x 

−x 

om x ≥ 0 

annars


Alternering med vakter 

I matematik: 

abs(x) = 

 

x 

−x 

om x ≥ 0 

annars 

I Haskell: 

abs x | x >= 0 = x 

| otherwise = -x 

Eng: guarded expression.


Istället för 

Mönsterpassning 

icke b = if b == True 

then False 

else True 

skriv 

icke True = False 

icke False = True


Mönsterpassning på listor 

Huvudet på en lista: 

head [] = error "No head on an empty li 

head (e : restOfList) = e



Huvudet på en lista: 


head (e : restOfList) = e 

eller: 


head (e : _ ) = e



Räkna blanka i en sträng: 

countSpaces :: String -> Int 

countSpaces [] = 0 

countSpaces (c : restOfString) 

= let d = if c == ’ ’ then 1 

else 0 

in d + countSpaces restOfString



Räkna blanka i en sträng: 



countSpaces (c : restOfString) 

= let d = if c == ’ ’ then 1 

else 0 

in d + countSpaces restOfString 

eller: 



countSpaces (’ ’ : restOfString) 

= 1 + countSpaces restOfString 

countSpaces (_ : restOfString) 

= 0 + countSpaces restOfString


• Mer om rekursion 

• Ackumulering 

• Polymorfism 

• Typklasser 

• Typkonvertering 

• Currying 

Härnäst

f2.pdf

Create successful ePaper yourself

Delete template?

Save as template?