Föreläsning 8. Hudak kapitel 13. 2D1370 Funktionell programmering v15 torsdag Olika sorters program. Inmatning sker innan exekveringen startar under exekvering När exekvering sker bestäms av datorn "transformerande system" t ex lab1, Quicksort kompilatorer interaktiva system t ex Schacket (lab2) (inmatade klickningar") redigeringsprogram ("editorer)" omgivningen reaktiva system t ex Klockan (lab4 ) (styrs av klocksignaler) datorspel (lab5) (styrs av musrörelser) inbyggda styr system oskarp gräns? Animering. Vad går kapitel 13 ut på? Vi gör i det följande följande importer : module Clock03 where import Animation -- Innehåller programmen i kapitel 13. import Shape import Region import Picture import SOEGraphics hiding (Region)
1. Statisk cirkel. Med våra kunskaper kapitel <= 10 lärde vi oss rita statiska (stillastående bilder). T ex staticball :: Picture -- red static ball staticball = let ball:: Region ball = Shape ( Ellipse 0.2 0.2) in Region Red ball main5lkstatic = draw "Static ball" staticball draw ska ha ett argument av typen Picture. I kapitel 13 ska vi rita animerade (rörliga) bilder. För detta byter vi draw till animate. animate ska ha ett argument av typen Float -> Graphic, Hudak gör typdefinitioner så att han också kan skriva Time -> Graphic eller Animation Graphic. Se vidare boken 13.1 <= avsnitt <=13.3. Vi kan nu rita vår statiska cirkel med main5lkstaticwithanimate = animate "Static ball" (\t -> pictographic (staticball)) animate är förståss överkvalificerad för att rita en statisk bild men gör förståss snällt detta om vi sänder in en konstant funktion av tiden. Vi kan också använda animateb som har ett argument av typen, förklaras senare. main5lkstaticwithanimateb = animateb "Static ball" (Beh(\t -> staticball)) 2. Snurrande cirkel. Om vi istället ger en bild som är en varierande funktion av tiden så får vi en rörlig bild. -- revolving ball unlifted revolvingballlk :: Time -> Picture revolvingballlk t = let ball:: Region ball = Shape ( Ellipse 0.2 0.2) in Region Red (Translate (sin t, cos t) ball) main5lkrevwithanimate = animate "Static ball" (\t -> pictographic (revolvingballlk t)) main5lkrevwithanimateb = animateb "Static ball" (Beh(\t -> revolvingballlk t)) Nu tycker emellertid Hudak att detta kan programmeras mycket elegantare om vi har animerade tidberoende motsvarigheter till det vi hitills gjort statiskt, t ex för Shape, Region, Ellipse osv. Dessutom vill han att vi skall kunna göra tidsberoende funktioner rent generellt, och skapa en "algebra" för sådana tidberoende funktioner så att man kan adderade tidsberoende funktioner, boolska tidsberoende värde beroende på tidsberoende funktioner osv. Dessutom vill han kunna använda operatorer som + == osv i den nya algebran. Dvs han vill att vår nya typ i vår nya algebra skall kunna vara instanser av Num, Eq osv. "Typklasser kommer till vår räddning". Den nya typen finns på sid 173 newtype a = Beh (Time -> a) newtime syntktiskt ekvivalet med data vid 1 konstuktor. animateb är en variant av animate som ska ha ett argument av typen F Picture.
Vårt exempel kan då skrivas (i boken och i Animation.hs) -- revolving ball lifted (Boken sid 178. I Animation.hs) {- revolvingballb :: Picture revolvingballb = let ball = shape (ell 0.2 0.2) in reg red (translate (sin time, cos time) ball) main5 :: IO () main5 = animateb "Revolving Ball " revolvingballb -} 2. Snurrande färgvarierande cirkel. OmVår cirekl både snurrar runt och växlar färg. -- flashing revolving ball unlifted flashlk :: Time -> Color flashlk t sin t > 0 = Red otherwise = Yellow flashingballlk :: Time -> Picture flashingballlk t = let ball:: Region ball = Shape ( Ellipse 0.2 0.2) in Region (flashlk (8*t)) (Translate (sin t, cos t) ball) main6lk = animate "Flashing Ball" (pictographic. flashingballlk) -- med animate main6lkb = animateb "Flashing Ball" ( Beh flashingballlk) Vårt exempel kan istället skrivas i vår ny algebra (i boken och i Animation.hs) {- -- flashing revolving ball unlifted animateb flash :: Color flash = cond (sin time >* 0) red yellow -- med animateb flashingball :: Picture flashingball = let ball = shape (ell 0.2 0.2) in reg (timetrans (8*time) flash) (translate (sin time, cos time) ball) main6 :: IO () main6 = animateb "Flashing Ball" flashingball -}
Tips inför "Klock-labben". Klocklabben bygger på många av alla de definitoner som görs i kapitel, 13. Dessa finns på /info/funpro02/soe/animation.lhs. Om du väljer att inte göra din klocka (lab4) direkt i module Animation kan samma importer som görs på första sidan vara lämpliga att göra för att lösa klocklabben. Men module Animation måste då också utökas med några rader. Definitionerna för att göra a till en typ i Num a finns också i /info/funpro02/soe/animation.lhs. lhs-suffix i ett filnamn anger "litterate" mode, dvs Haskelltexten är utmärktmed > och den förklarande förklarande texten icke utmärkt, dvs "tvärt-om-mode" till vanlig programtext på filer med hs-suffix där förklarande texten är utmärkt som kommentarer med -- eller "{- -}. Se hugs-manualen Hugs-eller ingressen i filerna. Hugs kan läsa båda filformaten. Jag har alltså skrivit om /info/funpro02/soe/animation.lhs till /info/funpro02/soe/animation.hs. Utgå från denna fil vid konstruktion av klockan i lab 4. Min enklaste lösning innebär tillägg/ändringarar av 19 rader för att få en fungerande klocka. Massor av rader i Animation.hs har förstås med andra program i kap 13 att göra och kan tas bort. Sedan har jag gjort andra varianter, delvis pga att min dator (Ultra 5) är långsammare än datorerna i terminalrummen så att vissa trimmningar är bra att göra. Jag har också gjort en ställbar klocka. "Lifting". Ett exempel på användning av typklasser som påminner om hur förpakar funktioner i kapitel 13: Låt oss definiera f:: Float -> Float -- (1) f t = sin t + cos t och g t = sin t h t = cos t Vi vill att följande uttryck skulle kunna definiera f stället för (1) ovan, dvs vi vill ge + ytterligen en betydelse "plussa ihop funktioner" när operatorn omges av funktioner av typ Float -> Float: f = g + h -- f samma betydelse som förut så förstår sig inte Haskell på detta, det går inget vidare om vi försöker: Type checking ERROR "Diverse.hs" (line 35): Instance of Num (Float -> Float) required for definition of f
Det vi menar är att vi vill ha en funktion definierad så här plusf :: (Float -> Float) -> (Float -> Float) -> (Float -> Float) plusf f1 f2 = \t -> f1 t + f2 t Nu kan vi skriva f = g plusf h -- f samma betydelse som förut Men om vi till varje pris vill att operatorn skall vara +, dvs om vi vill överladda +? Jo, om vi förpackar funktionerna i en typ 1, som vi senare gör till instans av Num kan vi "plussa förpackade funktioner" : data 1 = Beh1(Float -> Float) newtype alt till data om endast en konstruktor, ger effektivare program : newtype 1 = Beh1(Float -> Float) Förpackning av g och h: g2 = Beh1 (g) h2 = Beh1 (h) Så gör vi 1 till instans av Num, men vi gör ett första försöket så att bara (+) finns: instance Show 1 where show = error "" -- krävs pga Num ärver Show instance Eq 1 where -- krävs pga Num ärver Eq (==) = error "" instance Num 1 where (+) = \ (Beh1 f1) -> \(Beh1 f2) -> Beh1 (\t -> f1 t + f2 t) (-) = error "" (*) = error "" negate = error "" abs = error "" signum = error "" frominteger = error "" Nu fungerar "plussnig av förpackade funktioner".: f2 = g2 + h2 Vi kan skriva metoder för alla operationer i typklassen Num för instansen 1 : instance Num 1 where (+) = \ (Beh1 f1) -> \(Beh1 f2) -> Beh1 (\t -> f1 t + f2 t) (-) = \ (Beh1 f1) -> \(Beh1 f2) -> Beh1 (\t -> f1 t - f2 t) (*) = \ (Beh1 f1) -> \(Beh1 f2) -> Beh1 (\t -> f1 t * f2 t) negate = \ (Beh1 f) -> Beh1 (\t -> - (f t) ) abs = \ (Beh1 f) -> Beh1 (\t -> abs (f t)) signum = \ (Beh1 f) -> Beh1 (\t -> signum (f t))
frominteger = \i ->Beh1 (\t -> frominteger i) Hudak skulle skriva så här istället i (+) (Beh1 f1) (Beh1 f2) = Beh1 (\t -> f1 t + f2 t) vilket enligt definition av syntaxen för lamdauttryck (funktionsabstraktion) är exakt samma sak. Det underlättar tycker jag om man utan problem kan skriva och lösa funktionsdefinitioner på båda sätten. Definitionerna ovan är ju lite tjatiga, nästan samma sak hela tiden för t ex (+), (-) och (*) En lat (fiiffig?) funktionell programmerare fixar detta som vanligt med FUNKTIONER! lift2 f = \(Beh1 f1) -> \(Beh1 f2) -> Beh1(\t -> f (f1 t) (f2 t)) lift1 f = \ (Beh1 f1) -> Beh1 (\t -> f (f1 t) ) instance Num 1 where (+) = lift2 (+) (-) = lift2 (-) (*) = lift2 (*) negate = lift1 negate abs = lift1 abs signum = lift1 signum frominteger = \i ->Beh1 (\t -> frominteger i) Fortfarande fungerar "plussnig av förpackade funktioner", men också fler operatorer i Num : f2 = g2 + h2 f3 = g2 - f 2 Selektorer (som head, tail osv som "plockar sönder sammansatta värden av olika typer) behövs inte så ofta i funktionell programmering p g a att vi mönsterpassar ("pattern matchar") i stället, men här kan det vara bra att ha en selektor för att plocka ut funktionen ur förpackningen: unpack (Beh1 f) = f Nu kan vi t ex göra följande provkörning som trycker ut de 10 första värdena av f2(alfa), där alfa = 0, π /4, 2π /4, 3π /4 osv : Main> take 10 (map (unpack f2)[0.0, pi/4.0..]) [1.0,1.41421,1.0,0.0,-1.0,-1.41421,-1.0,-2.38419e-07,1.0,1.41421] Vi har här använt ett argument som är en oändlig lista [a, b,.. ], något som Hudak skriver om i kapitel 14.
Animering. Vad gör Hudak i kapitel 13? Jo, för de viktigaste konstruerarna, funktionerna och typerna i kapitlen <= 10 som ju handlade om statika bilder gör han motsvarande tidsberoende funktioner och typer. Detta sker med lyftning. Här är en förenklad bild av vad vi lärde oss för statiska bilder och motsvarande "lyfta" funktioner och typer i kapitel 13 (dvs i Animation ) för animerade bilder: Float Float Rectangle RtTriangle Ellipse ell Shape Shape Shape shape Region Region Region Translate Red Magenta Yellow White red yellow translate Color Color Region over EmptyPic Color reg over empty Black Blue Green Cyan Picture Kap 10 Picture Picture String draw IO() animateb String IO()
Som synes är t ex bara två färger "lyfta", så för att göra en färggrann klocka behöver man komplettera med att lyfta fler färger. Även en del annat kan behöva lyftas, tex kan man bara rita ellipser än så länge. Men lyftning är ju lätt med våra lyftfunktioner, se hur Hudak gör med saker som redan är lyftade. Men typen newtype a = Beh (Time -> a) som ju "förpackar funktioner" kan ju användas för mycket annat än bilder, regioner och sånt. Det är då praktiskt att göra till en instans av typklasser Num, Eq, Show, Fractional och Floating, vilket är lika lätt med lyftfunktioner, se sid 174. Dessutom gör Hudak en ny klass Combine och gör a till instans och dessutom ytterligare några nya operatorer och funktioner. Slutresultatet blir en algebra eller ett språk för förpackade funktioner av typen (Time -> a) eller om man så vill (Float -> a) som man kan använda för att göra animationer, t ex filmen Toy Story ( i princip). Jag hoppas att det nu skall var lite lättare att tugga i sig kapitel 13 och att göra labben. Kör gärna animationerna i Animation, t ex kaleidoskåpet main8.