Föreläsning 7 i programmeringsparadigm. Ytterligare Högre ordningens funktioner: filter, foldr foldl. Hutton 7.2, 7.3 och 7.4. filter se Hutton. När man använder filter och map får man ofta glädje av anonyma funktioner och partiell applikation. filter och map kan ersättas med listomfattningar; [ uppbyggnad av ny element, ~ f.. i map f mönster <- lista,... <-, predikat,...] Man har ofta anledning att "vika ihop" listor, dvs slå samman alla elementen med hjälp av en binär operator/funktion. T ex om vi skall summera elementen i en lista: [1, 14, 5] (dvs listan 1: 14: 5 : []) kan vi se detta som om vi skall stoppa in ett + efter elementen och en nolla längst åt höger ( " ~ på alla ställen där det står ett,") (eller alternativt byta : mot + och [] med 0.) (1 + (14 + (5 + 0))) Detta har vi gjort med denna definition sum :: Num a => [a] -> a sum [] = 0 sum (x:xs) = x + sum xs Detta kan vi generalisera för godtycklig binär operator/funktion, godtyckligt värde "längst till höger" : foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) Vi skulle kunna kan nu definiera sum = foldr (+) 0 T e x sum [1, 14, 5] foldr (+) 0 [1, 14, 5] foldr (+) 0 (1:14:5:[]) (vi stoppar in + infixt ) (1 + foldr (+) 0 (14:5:[])) (1 + (14 + foldr (+) 0 (5:[])) (1 + (14 + (5 + foldr (+) 0 []))) (1 + (14 + (5 + 0))) (1 + (14 + 5)) (1 + 19) 20
r i foldr står för right, "paranteserna till höger". foldl "paranteserna till vänster left": foldl f z [] = z foldl f z (x:xs) = foldl f (f z x) xs Observera att foldl är svansrekursiv; I det rekursiva fallet är högerledet ett enklet anrop till funktionen själv. Det successiva leden i reduktionen nedan bara anrop till med nya argument oberoende av startlistans längd. I Hutton disukteras i början på 7.4 "accumulering i parameter" v i sum. sum är i preluden definierad med en icke-lat (kommer i föreläsning 8) variant av foldl (varför?) : sum = foldl (+) 0 Reduktion: sum [1, 14, 5] foldl (+) 0 [1, 14, 5] foldl (+) 0 (1:14:5:[]) (vi stoppar in + infixt ) foldl (+) (0+1) (14:5:[]) foldl (+) (1+14) (5:[]) foldl (+) (15+5) [] 20 concat är i Prelude definierad med foldr : concat = foldr (++) [] Typklasser. Ibland är det bekvämt att kunna ha samma namn på olika funktioner, men funktioner som gör liknade saker trots att de jobbar med olika typer. Tex som tar en String som argument men levererar ett resultat av godtycklig typ. (Resultatet är ett värde, detta värde finns i samtliga typer i Haskell vilket jag hitills inte låtsas om, och kallas "bottom". Eftersom beräkningen är klar sker inget mer. Hugs skriver dock ofta Program : och skriver ut strängen. [->->Bool] (, Double) ->... String... Eftersom resultattypen kan vara vilken typ som helst skriver vi :: String -> a På ganska analogt sätt är typen för funktionen för listors längd length :: [a] ->, dvs elementtypen kan var vilken typ som helst.
Repetition: I början av kursen definierade vi sådant som length :: [] -> length [] = 0 length (a:as) = 1 + length as sumlist :: [] -> sumlist [] = 0 sumlist (a:as) = a + sumlist as När vi lärt oss mer konstaterade vi att typen på a spelar ingen roll för length så vi gjorde istället length :: [a] -> length [] = 0 length (_:as) = 1 + length as eller t o m lengthlk :: [a] -> lengthlk = foldr (\a -> \rea -> 1+rea ) 0 eller t o m lengthlk :: [a] -> lengthlk = foldr (\a -> (1+) ) 0 Men sumlist då? Kan vi göra detsamma för sumlist? Nej vi kan bara summera listor med t ex, eger, Double och Float men inte alla möjliga listor, inte listor med funktioner t ex. varför typen [a] -> a är för generell. Men om vi skriver Num" så går det bra. Num a => [a] -> a, vilket betyder "för alla typer a som ingår i typklassen Typklassen Num innehåller "alla typer man göra + - * (och en del mer) på." Man kan alltså gruppera typer i typklasser: Ytterligare exempel: Låt oss titta på applikationer ("körningar") av funktionen fromenum i Hugs : Main> fromenum 14 14 Main> fromenum True 1 Main> fromenum 14.4 14 Main> fromenum a 97 Main> fromenum (2, a ) ERROR - Illegal Haskell 98 class constraint in inferred type *** Expression : fromenum (2, a ) *** Type : (Num a, Enum (a,char)) => Main> fromenum [2,3] ERROR - Illegal Haskell 98 class constraint in inferred type... Main> fromenum (\x -> x+3) ERROR - Illegal Haskell 98 class constraint in inferred type...
Uppenbarligen är fromenum :: a-> -- FEL!!!!! för generellt, medan t ex fromenum :: -> -- FEL!!! är för specifikt Den korrekta typen är fromenum :: Enum a => a -> Vilket betyder alla typer a som är instanser i typklasen Enum (är med i "gänget" Enum). Double Bool () Char (, Double) Float [->->Bool] Ordering eger... Enum... Kan man göra typklasser själv? Naturligtvis! Kan man göra typer i Preluden till instanser i typklasser man gjort själv? Naturligtvis! Kan man göra egna typer till instanser i typklasser man gjort själv? Naturligtvis! Kan man göra egna typer till instanser i typklasser i Preluden? Naturligtvis! Är typklasser och instanser till typklasser definierade med Haskell i preluden? Naturligtvis! Definition av typklass: namn på typklassen täcknamn på typ vi definierar i typklassen så vi kan skriva metodernas typ class Eq a where (==), (/=) :: a -> a -> Bool --Minimal comp def: (==) or (/=) x == y = not (x/=y) x /= y = not (x==y) metoder med typ som alla typer som vill vara instanser (medlammar) i typklassen måste ha "defaulta" def av metoder med andra av metoderna; vi behöver därför ofta bara def vissa av metoder I diagrammet nästa sida: Typklass definition (ofta utan defafault-def, se preluden) arv Eq class Eq a wheree... Alla utom IO (->) instanser (medlemmar) i typklassen
Eq class Eq a where (==), (/=) :: a -> a -> Bool -- Minimal c def: (==) or (/=) x == y = not (x/=y) x /= y = not (x==y) Alla utom IO (->) Show class Show a where show :: a -> String showsprec :: -> a -> ShowS showlist :: [a] -> ShowS -- Mini definition: show or showsprec -- Def simp e Prelude Alla Prelude types Ord class (Eq a) => Ord a where compare :: a -> a -> Ordering (<),(<=),(>=),(>):: a -> a -> Bool max, min :: a -> a -> a -- Min c def: (<=) or compare -- compare can be more efficient compare x y x==y = EQ x<=y = LT otherwise = GT -- Default imp se Prelude Alla utom IO IOError (->) Enum class Enum a where succ, pred :: a -> a toenum :: -> a fromenum ::a-> enumfrom ::a->[a] -- [n..] enumfromthen ::a->a->[a] -- [n,m..] enumfromto ::a->a->[a] -- [n..m] enumfromthento::a->a->a->[a] --[n,n..m] -- Min com def: toenum, fromenum -- Def imp se prelude () Bool Char Ordering eger Float Double Num class (Eq a, Show a) => Num a where (+), (-), (*) :: a -> a -> a negate :: a -> a abs, signum :: a -> a fromeger :: eger -> a from :: -> a -- Min comp def: All, -- except negate or (-) -- Def imp se prelude, eger, Float Double Real class (Num a, Ord a) => Real a where torational::a->rational Alla utom IO (->) Fractional class (Num a)=>fractional a where (/) ::a->a->a recip ::a->a fromrational::rational->a fromdouble ::Double->a -- Min comp def: fromrational --and ((/) or recip) -- Def imp se prelude Float Double egral class (Real a, Enum a) => egral a where quot,rem,div,mod::a->a->a quotrem,divmod::a->a->(a,a) even, odd ::a->bool toeger ::a->eger to ::a-> --Min comp def:quotrem --and toeger Def Prelude eger RealFract class (Real a, Fractional a) => RealFrac a where properfraction::(egral b)=> a -> (b,a) truncate,round::(egral b)=> a -> b ceiling, floor::(egral b)=> a -> b -- Def imp i Prelude Float Double Floating Float Double RealFloat Float Double
Översikt av Preludens viktigaste typklass: Föregående sida och denna sida.. class (Fractional a) => Floating a where -- instanser Float Doubble pi :: a exp, log, sqrt :: a -> a (**), logbase :: a -> a -> a sin, cos, tan :: a -> a asin, acos, atan :: a -> a sinh, cosh, tanh :: a -> a asinh, acosh, atanh :: a -> a -- Minimal complete definition: pi, exp, log, sin, cos, sinh, -- cosh,asinh, acosh, atanh -- Defaulta implemntationer se Preluden (Det som man lär sig i -- matte) class (RealFrac a, Floating a) => RealFloat a where -- instanser Float Doubble floatradix :: a -> eger floatdigits :: a -> floatrange :: a -> (,) decodefloat :: a -> (eger,) encodefloat :: eger -> -> a exponent :: a -> significand :: a -> a scalefloat :: -> a -> a isnan, isinfinite, isdenormalized, isnegativezero, isieee :: a -> Bool atan2 :: a -> a -> a -- Minimal complete definition: All, except exponent, signficand, -- scalefloat, atan2 -- Defaulta implemntationer se Preluden (Det som man lär sig i -- matte) -- Några numeriska funktioner i Prelude -------------------------------------------------------- subtract :: Num a => a -> a -> a subtract = flip (-) gcd (^) (^^) fromegral realtofrac :: egral a => a -> a -> a :: (Num a, egral b) => a -> b -> a :: (Fractional a, egral b) => a -> b -> a :: (egral a, Num b) => a -> b :: (Real a, Fractional b) => a -> b Hur man gör en typ till instans (medlem) av en typklass: instance Eq Mintyp where --- här skriver man (åtminstone) de funktioner som behövs
Vitsen med typklasser. Möjliggör överlagring (overloading) av funktioner och operatorer. T ex kan == användas för "lika med" för två värden av en mängd olika typper, trots att == utföres på olika sätt beroende på vilka typer operanderna har. Att jämföra två värden av typen String är inte samma sak som att jämföra två värden av typen till exempel. Nya typklasser definieras alltså med class. Typklasser motsvarar delvis Javas interface, men i Java används interfacenamnet som en typ, i Haskell skrivs typklassnamnet före => som kvalfierare för a "i contexten", t ex: Ord a => <här typuttryck med a> I vårt utdrag ur Hutton står det om överlagring (overloading) och typklasser i avsnitt 3.8 och 3.9. Men hur man skriver egna klasser behandlas icke. Hutton kallas typklasser för classes. Jag har använt ordet typklasser för att betona att instanserna i en typklass är klasser. I Java är instanserna i en Java-klass objekt. Vitsen med konstruktioner som fromeger(toeger n) : typklassen egral typklassen Num har bla toeger har bla fromeger eger eger Float Double eger Endast två funktionsnamn behövs istället för 6-8 om man skulle ha funktioner. toeger är alltså en metod som motsvaras av två olika funktioner och fromeger är alltså en metoder som motsvaras av 4 olika funktioner. I ett visst uttryck väljer Haskell alltså automatisktde de funktioner som passar i sammanhanget. Float eger Double eger
Den "överlagrade funktionen" toeger är i och för sig impementerat med två olika funktioner, och den "överlagrade funktionen" fromeger med 3 olika funktioner, men dessa behöver Haskellprogrammeraren inte känna till. Repetition av olika definitioner i Haskell: Vi kan nu definiera nya namn.. på : värden: namn på funktioner (liten bokstav)......=.. eller (liten bokstav).. = <lamdauttryck> namn på konstanter (liten bokstav).. =.. namn på konstruerarfunktioner (Stor bokstav ) data... =........ namn på konstruerakonstanter (Stor bokstav ) data... =.. Används i uttryck typer: namn på typer (Stor bokstav ) data.. =...... namn på typsynonymer (Stor bokstav ) type.. =... namn på typvariabler (liten bokstav) (ingen def.!) Används efter :: (Röda värden) typklasser: namn på typklasser (Stor bokstav ) class.. a where Används före => moduler: namn på moduler (Stor bokstav ) module.. where Används efter import Lat evaluering. Hutton kapitel 12. (Fokker 3.2.5, 3.2.6 sid 48-51). Haskell och "moderna" funktionella språk har lat evaluering. Jag har några ex av Björn vonsydow: Datastrukturer i Haskell" (48 s). Mycket trevlig läsning som bland annat tar upp mer om hur Haskell fungerar, lat evluering och effektivitetssynpunkter. Har används på Chalmers i fortsättningskursen i programmering