Praktische Informatik 3: Einführung in die Funktionale Programmierung

Praktische Informatik 3: Einführung in die Funktionale Programmierung

Vorlesung vom 05.01.2011: Signaturen und Eigenschaften

Christoph Lüth & Dennis Walter Universität Bremen Wintersemester 2010/11

Rev. 1312 1 [26]

Fahrplan

I Teil I: Funktionale Programmierung im Kleinen I Teil II: Funktionale Programmierung im Großen

IAbstrakte Datentypen

ISignaturen und Eigenschaften

IAktionen und Zustände

I Teil III: Funktionale Programmierung im richtigen Leben

2 [26]

Abstrakte Datentypen

ILetzte Vorlesung:Abstrakte Datentypen

ITypplusOperationen

IIn Haskell:Module

IHeute:SignaturenundEigenschaften

3 [26]

Signaturen

Definition (Signatur)

DieSignatureines abstrakten Datentyps besteht aus den Typen, und der Signatur der darüber definierten Funktionen.

I Keine direkte Repräsentation in Haskell

I Signatur:Typeines Moduls

4 [26]

Zur Erinnerung: Endliche Abbildungen

IEndliche Abbildung(FiniteMap)

ITypen: die AbbildungS, Adressena, Werteb IOperationen (Auszug)

IleereAbbildung:S

IAbbildung an einer Stelleschreiben:S→a→b→S

IAbbildung an einer Stellelesen:S→a*b(partiell)

5 [26]

Endliche Abbildung: Signatur

I AdressenundWertesindParameter type Map α β

I Leere Abbildung:

empty :: Map α β

I An eine Stelle einen Wertschreiben:

i n s e r t :: Map α β→ α → β→ Map α β I An einer Stelle einen Wertlesen:

l o o k u p :: Map α β→ α → Maybe β

6 [26]

Signatur und Eigenschaften

ISignatur genug, um ADTtypkorrektzu benutzen

IInsbesondereAnwendbarkeitundReihenfolge

ISignatur nicht genug, umBedeutung(Semantik) zu beschreiben:

IWaswirdgelesen?

IWieverhältsich die Abbildung?

7 [26]

Beschreibung von Eigenschaften

Definition (Axiome)

AxiomesindPrädikateüber denOperationender Signatur I ElementarePrädikateP:

IGleichheits==t

IOrdnungs<t

ISelbstdefinierte Prädikate I ZusammengesetztePrädikate

INegationnot p

IKonjunktionp && q

IDisjunktionp| | q

IImplikationp=⇒q

8 [26]

Beobachtbare und Abstrakte Typen

IBeobachtbareTypen: interne Struktur bekannt

IVordefinierte Typen (Zahlen,Zeichen), algebraische Datentypen (Listen)

IViele Eigenschaften und Prädikate bekannt IAbstrakteTypen: interne Struktur unbekannt

IWenig Eigenschaft bekannt, Gleichheit nur wenn definiert IBeispielMap:

Ibeobachtbar: Adressen und Werte

Iabstrakt: Speicher

9 [26]

Axiome für Map

I Lesenaus leerer Abbildung undefiniert:

l o o k u p empty a == N o t h i n g

I Lesenan vorher geschriebener Stelle liefert geschriebenen Wert:

l o o k u p ( i n s e r t m a b ) a == J u s t b I Lesenan anderer Stelle liefert alten Wert:

a1 /= a2 =⇒ l o o k u p ( i n s e r t m a1 b ) a2 ==

l o o k u p m a2

I Schreibenan dieselbe Stelle überschreibt alten Wert:

i n s e r t (m a b1 ) a b2 == i n s e r t m a b2 I Schreibenüber verschiedene Stellen kommutiert:

a1 /= a2 =⇒ i n s e r t ( i n s e r t m a1 b1 ) a2 b2 ==

i n s e r t ( i n s e r t m a2 b2 ) a1 b1

10 [26]

Axiome als Interface

IAxiome müssengelten

IfüralleWerte der freien Variablen zuTrueauswerten IAxiomespezifizieren:

Inach außen dasVerhalten

Inach innen dieImplementation ISignatur+Axiome=Spezifikation

Nutzer Spezifikation Implementation

IImplementation kanngetestetwerden IAxiome können (sollten?)bewiesenwerden

11 [26]

Signatur und Semantik

Stacks Typ:Stα Initialwert:

empty :: S t α Wert ein/auslesen:

p u s h :: α→ S t α→ S t α t o p :: S t α→ α pop :: S t α→ S t α Test auf Leer:

i s E m p t y :: S t α→ B o o l Last in first out (LIFO).

Queues Typ:Quα Initialwert:

empty :: Qu α Wert ein/auslesen:

enq :: α→ Quα→ Quα

f i r s t :: Qu α→ α

deq :: Qu α→ Qu α

Test auf Leer:

i s E m p t y :: Quα→ B o o l First in first out (FIFO) GleicheSignatur, unterscheidlicheSemantik.

12 [26]

Eigenschaften von Stack

Last in first out (LIFO):

t o p ( p u s h a s ) == a pop ( p u s h a s ) == s i s E m p t y empty

n o t ( i s E m p t y ( p u s h a s ) ) p u s h a s /= empty

13 [26]

Eigenschaften von Queue

First in first out (FIFO):

f i r s t ( enq a empty ) == a

n o t ( i s E m p t y q ) =⇒ f i r s t ( enq a q ) == f i r s t q deq ( enq a empty ) == empty

n o t ( i s E m p t y q ) =⇒ deq ( enq a q ) = enq a ( deq q ) i s E m p t y ( empty )

n o t ( i s E m p t y ( enq a q ) ) enq a q /= empty

14 [26]

Implementation von Stack: Liste

Sehr einfach: ein Stack ist eine Liste

data S t a c k a= S t a c k [ a ] d e r i v i n g ( Show , Eq ) empty = S t a c k [ ]

p u s h a ( S t a c k s ) = S t a c k ( a : s )

t o p ( S t a c k [ ] ) = e r r o r " S t a c k : t o p on empty s t a c k "

pop :: S t a c k a→ S t a c k a

15 [26]

Implementation von Queue

I Mit einerListe?

IProblem: am Ende anfügen oder abnehmen ist teuer.

I DeshalbzweiListen:

IErste Liste: zuentnehmendeElemente

IZweite Liste:hinzugefügteElementerückwärts

IInvariante: erste Liste leer gdw. Queue leer

16 [26]

Repräsentation von Queue

Operation Resultat Queue Repräsentation

empty ([], [])

enq 9 9 ([9], [])

enq 4 4→9 ([9], [4])

enq 7 7→4→9 ([9], [7, 4])

deq 9 7→4 ([4, 7], [])

enq 5 5→7→4 ([4, 7], [5])

enq 3 3→5→7→4 ([4, 7], [3, 5])

deq 4 3→5→7 ([7], [3, 5])

deq 7 3→5 ([5, 3], [])

deq 5 3 ([3], [])

deq 3 ([], [])

deq error ([], [])

17 [26]

Implementation

I Datentyp:

data Qu α=Qu [α] [α]

I Leere Schlange: alles leer empty =Qu [ ] [ ]

I Invariante: erste Liste leer gdw. Queue leer i s E m p t y (Qu x s _) = n u l l x s I Erstes Element steht vorne in erster Liste

f i r s t (Qu [ ] _) = e r r o r " Queue : f i r s t o f empty Q"

f i r s t (Qu ( x : x s ) _) = x

18 [26]

Implementation

IBeienqunddeqInvariante prüfen

enq x (Qu x s y s ) = c h e c k x s ( x : y s )

deq (Qu [ ] _ ) = e r r o r " Queue : deq o f empty Q"

deq (Qu (_ : x s ) y s ) = c h e c k x s y s

IPrüfung der Invariantenachdem Einfügen und Entnehmen IcheckgarantiertInvariante

c h e c k :: [α]→ [α]→ Qu α c h e c k [ ] y s =Qu ( r e v e r s e y s ) [ ] c h e c k x s y s =Qu x s y s

19 [26]

Axiome als Eigenschaften

I Axiome könnengetestetoderbewiesenwerden I Tests findenFehler, Beweis zeigtKorrektheit I Artenvon Tests:

IUnit tests(JUnit, HUnit)

IBlack Boxvs.White Box

IZufallsbasiertesTesten

I Funktionale Programme eignen sichsehr gutzum Testen

20 [26]

Zufallsbasiertes Testen in Haskell

IWerkzeug:QuickCheck

IZufällige Werteeinsetzen, Auswertung aufTrueprüfen IPolymorphe Variablen nichttestbar

IDeshalb Typvariableninstantiieren

ITyp muss genug Element haben (hierInt)

IDurch SignaturTypinstanzerzwingen

IFreie Variablender Eigenschaft werdenParameterder Testfunktion

21 [26]

Axiome mit QuickCheck testen

I Für das Lesen:

p r o p _ r e a d _ e m p t y :: I n t→ B o o l p r o p _ r e a d _ e m p t y a =

l o o k u p ( empty :: Map I n t I n t ) a == N o t h i n g p r o p _ r e a d _ w r i t e :: Map I n t I n t→ I n t→ I n t→ B o o l p r o p _ r e a d _ w r i t e s a v=

l o o k u p ( i n s e r t s a v ) a == J u s t v

I Hier: Eigenschaften direkt alsHaskell-Prädikate

I Es werdenNZufallswerte generiert und getestet (N=100)

22 [26]

Axiome mit QuickCheck testen

IBedingteEigenschaft inquickCheck:

IA=⇒BmitA,BEigenschaften

ITyp istProperty

IEs werden solange Zufallswerte generiert, bisNdie Vorbedingung erfüllende gefunden und getestet wurden, andere werden ignoriert.

p r o p _ r e a d _ w r i t e _ o t h e r ::

Map I n t I n t→ I n t→ I n t→ I n t→ P r o p e r t y p r o p _ r e a d _ w r i t e _ o t h e r s a v b=

a /= b =⇒ l o o k u p ( i n s e r t s a v ) b == l o o k u p s b

23 [26]

Axiome mit QuickCheck testen

I Schreiben:

p r o p _ w r i t e _ w r i t e :: Map I n t I n t→ I n t→ I n t→ I n t→ B o o l p r o p _ w r i t e _ w r i t e s a v w=

i n s e r t ( i n s e r t s a v ) a w== i n s e r t s a w I Schreibenan anderer Stelle:

p r o p _ w r i t e _ o t h e r ::

Map I n t I n t→ I n t→ I n t→ I n t→ I n t→ P r o p e r t y p r o p _ w r i t e _ o t h e r s a v b w=

a /= b =⇒ i n s e r t ( i n s e r t s a v ) b w==

i n s e r t ( i n s e r t s b w) a v I Test benötigtGleichheitaufMap a b

24 [26]

Zufallswerte selbst erzeugen

IProblem:ZufälligeWerte vonselbstdefiniertenDatentypen

IGleichverteiltheitnicht immer erwünscht (e.g.[a])

IKonstruktionnicht immer offensichtlich (e.g.Map) IInQuickCheck:

ITypklasseclass Arbitrary afürZufallswerte

IEigeneInstanziierungkann Verteilung und Konstruktion berücksichtigen

IE.g.KonstruktioneinerMap:

IZufällige Länge, dann aus sovielen zufälligen WertenMapkonstruieren

IZufallswerte in Haskell?

25 [26]

Zusammenfassung

I Signatur: Typ und Operationen eines ADT I Axiome: über Typen formulierteEigenschaften

I Spezifikation= Signatur + Axiome

IInterfacezwischen Implementierung und Nutzung

ITestenzur Erhöhung der Konfidenz und zum Fehlerfinden

IBeweisender Korrektheit I QuickCheck:

IFreie Variablen der Eigenschaften werdenParameterder Testfunktion

I=⇒fürbedingteEigenschaften

26 [26]