Grundlagen der Programmierung 2 - Benutzer-Homepagesprg2/SS2011/folien/teil1/fol-1… · Grundlagen der Programmierung 2: Geplanter Inhalt der ersten H¨alfte Grundlagen der Programmierung

1

Grundlagen der Programmierung 2

Prof. Dr. Manfred Schmidt-Schauÿ

Künstliche Intelligenz und Softwaretechnologie

14. April 2011

Grundlagen der Programmierung 2:Geplanter Inhalt der ersten Halfte

Grundlagen der Programmierung 2 (1.A) - 2 -

• rekursives Programmieren in Haskell• Auswertung in Haskell• Programmieren mit Listen• Strome als unendliche Listen in Haskell• Polymorphe Typen und Typklassen• Compilerbau; Einfuhrung• Semantik; parallele Auswertung

Bucher, Literatur, URLs


• http://www-stud.informatik.uni-frankfurt.de/˜prg2• www.haskell.org Haskell-Web-Seite

• http://haskell.org/onlinereport/ Haskell-Doku

• Manuel Chakravarty und Gabriele Keller, Einfuhrung in die

Programmierung mit Haskell• Richard Bird, Introduction to Functional Programming Using

Haskell• Simon Thompson, Haskell: The Craft of Functional Program-

ming• Graham Hutton, Programming in Haskell (2007)

Haskell


rekursive Programmierung

mit einer stark typisierten

funktionalen Programmiersprache

mit parametrischem Polymorphismus

Haskell

Haskell


Haskell ist eine moderne Programmiersprache;

sehr weitgehende Konzepte werden erprobt und kombiniert

strenge und statische TypisierungNicht-strikte Auswertung

=⇒ viele korrekte Programmtransformationen=⇒ korrekte automatische Parallelisierung

Haskell


Wichtige Eigenschaften funktionaler Programmiersprachen

Referentielle TransparenzGleiche Funktion, gleiche Argumente =⇒ gleicher (Ruckgabe-)WertKeine Seiteneffekte! D.h. keine Anderung von Objekten

Verzogerte AuswertungNur die fur das Resultat notwendigen Unterausdrucke werden(so spat wie moglich) ausgewertet.

Parametrisch Polymorphes TypsystemNur Ausdrucke mit Typ sind erlaubt — es gibt Typvariablen.Das Typsystem garantiert: keine dynamischen Typfehler.

Automatische SpeicherverwaltungAnforderung und Freigabe von Speicher

PR zu Funktionalen Programmiersprachen


OCaml: Variante von ML, analog zu Haskell

Artikel von Yaron Minsky und Stephen Weeks: (JFP 2008)

Einige Zitate:

”Most importantly, using OCaml helps us find, hire, and retain great

programmers. . . .

The density of bright people in the OCaml community is impressive

and it shows up in hiring “

PR fur Funktionale Programmiersprachen


”OCaml . . . . It has allowed us to develop code to very high standards

of safety and correctness while rapidly adapting to changing markets.

“

”Immutability OCaml is not a pure language, but the default in

OCaml is for immutability.”

”Pattern Matching A great deal of what happens in many programs

is case analysis. . . . a convenient syntax for data-directed case analy-

sis, and a proof guaranteed by the compiler that the case analysis is

exhaustive“

PR fur Funktionale Programmiersprachen


”The current standard library is implemented well and provides

reasonable coverage, but it is missing a lot of useful functionality and

has a number of well-known pitfalls (perhaps the most commented

upon is the fact that a number of the functions in the list module are

not tail-recursive). “

(d.h. nicht endrekursions-optimiert: dazu kommen wir noch)

Programmierung in Haskell


Grundprinzipien: des funktionalen Programmierens

• Definition von Funktionen quadrat x = x*x

• Aufbau von Ausdrucken:Anwendung der Funktion auf Argumente, 3*(quadrat 5)

die wieder Ausdrucke sein konnen.

• programminterne Kommunikation:Nur der Wert von Ausdrucken wird bei der 75Auswertung zuruckgegeben.

• Funktionen konnen Datenobjekte sein

Standards zu Folien und Skript


Darstellung von Quell-Code (Source-code) auf den Folien und Skript:

quadrat x = x*x

Darstellung von Interpreteraktionen auf Folien und Skript:

*Main> 2+2 ←↩

4

Interpreter / Compiler fur Haskell


Wir verwenden den Interpreter GHCi

Im RBI verfugbar.

Einfacher Download und Installation

Umgang mit dem Interpreter


Online-Report http://www.haskell.org/onlinereport

Aufruf: ghci (im richtigen Fenster)

prompt > ghci ←↩

< several lines >

Prelude> :h ←↩

< Hilfe-Menu >

Prelude> :t True ←↩

True :: Bool (druckt den Typ des Ausdrucks

Prelude> :set +s ←↩ (Option s fur Statistik gesetzt)

Module im Interpreter verwenden:

Prelude> :m +Char +Numeric ←↩

Einfache Daten und Operatoren


• ganze Zahlen Typ Int

n mit |n| ≤ 231 − 1 = 2147483647• beliebig lange ganze Zahlen (vom Typ Integer),• rationale Zahlen 3%7 Typ: Ratio• Gleitkommazahlen 3.456e+10 Typ: Floating)• Zeichen ’a’ Typ Char

• Datenkonstruktoren True, False; Typ Bool

Diese nennen wir auch Basiswerte (bis auf Floating)

Einfache Daten und Operatoren


• Arithmetische Operatoren: +,−, ∗, /,(ein) Typ: Int → Int → Int

• Arithmetische Vergleiche: ==, <=, < . . .(ein) Typ: Int → Int → Bool

• Logische Operatoren: &&, ||, not(ein) Typ: Bool → Bool → Bool

Beispiel


Definition eines Polynoms x2 + y2:

quadratsumme x y = quadrat x + quadrat y

Auswertung:

... *Main> quadratsumme 3 4 ←↩

25

Typen in Haskell


TYP Ausdruck

Int 3Integer 123

Float 1.23e45Double 1.23e45

Integer -> Integer -> Integer (+)Integer -> Integer quadrat

Integer -> Integer -> Integer quadratsumme

Typ Konstanten,(Typ von Argument 1) -> (Typ von Argument 2) -> Ergebnistyp Funktionen

Typen in Haskell


Beispiel

Die Ausgabe des Interpreters fur die Addition (+) ist komplizierter:

Prelude> :t (+) ←↩

(+) :: (Num a) => a -> a -> a

D.h.: Fur alle Typen a, die man als numerisch klassifiziert hat,

d.h. die in der Typklasse Num sind,

hat (+) den Typ a -> a -> a

Z.B. gilt:

(+)::Integer -> Integer -> Integer

(+)::Double -> Double -> Double

(vereinfachte) Haskell-Syntax


〈FunktionsDefinition〉 ::= 〈Funktionsname〉〈Parameter〉∗ = 〈Ausdruck〉〈Ausdruck〉 ::= 〈Bezeichner〉 | 〈Zahl〉

| (〈Ausdruck〉〈Ausdruck〉)| (〈Ausdruck〉)| (〈Ausdruck〉〈BinInfixOp〉〈Ausdruck〉)

〈Bezeichner〉 ::= 〈Funktionsname〉 | 〈Datenkonstruktorname〉| 〈Parameter〉 | 〈BinInfixOp〉

〈BinInfixOp〉 ::= ∗ | + | − | /

Argumente einer Funktion: formale Parameter.Anzahl der Argumente: Stelligkeit der Funktion: (ar(f))

Die Nichtterminale

〈Funktionsname〉, 〈Parameter〉, 〈Bezeichner〉, 〈Datenkonstruktorname〉sind Namen (z.b.

”quadrat“)

Aus der Haskell-Dokumentation


http://www.hck.sk/users/peter/HaskellEx.htm

http://www.haskell.org/onlinereport/exps.html#sect3.2

exp10 -> \ apat1 ... apatn -> exp (lambda abstraction, n>=1)

| let decls in exp (let expression)

| if exp then exp else exp (conditional)

| case exp of { alts } (case expression)

| do { stmts } (do expression)

| fexp

fexp -> [fexp] aexp function application)

aexp -> qvar (variable)

| gcon (general constructor)

| literal

| ( exp ) (parenthesized expression)

| ( exp1 , ... , expk ) (tuple, k>=2)

| [ exp1 , ... , expk ] (list, k>=1)

| [ exp1 [, exp2] .. [exp3] ] (arithmetic sequence)

Beispiel zur Grammatik


quadratsumme x y = (quadrat x) + (quadrat y)

Zeichenfolge Name in der Grammatik (sog. Nichtterminal)im Programmquadratsumme 〈Funktionsname〉x 〈Parameter〉y 〈Parameter〉= = gleiches Zeichen wie in Grammatik(quadrat x) + (quadrat y) 〈Ausdruck〉 der Form 〈Ausdruck〉+ 〈Ausdruck〉+ binarer Infix-Operatorquadrat x Anwendung: quadrat ist ein Ausdruck

und x ist ein Ausdruck

Programm


Ein Haskell-Programm ist definiert als

• Eine Menge von Funktionsdefinitionen

• Eine davon ist die Definition der Konstanten main.

Ohne main: dann ist es ein Modul

Haskell: Verschiedenes . . .


Prelude: vordefinierte Funktionen, Typen und Datenkonstruktoren

Prafix, Infix, Prioritaten: ist moglich fur Operatoren

Konventionen zur Klammerung: s1 s2 . . . sn ≡ ((. . . (s1 s2) s3 . . .) sn)

Funktionsdefinitionen:

• formale Parameter mussen verschiedenen sein;

• keine undefinierten Variablen im Rumpf!

Weitere Trennzeichen: “{“,“}“ Semikolon “; “

Layout-sensibel: bewirkt Klammerung mit {, }.

Fallunterscheidung: IF-THEN-ELSE


Syntax: if 〈Ausdruck〉 then 〈Ausdruck〉 else 〈Ausdruck〉

”if“,

”then“,

”else“ sind reservierte Schlusselworte

Der erste Ausdruck ist eine Bedingung (Typ Bool)

Typisierung: if Bool . . . then typ else typ

(if 1 then 1 else 2)

ergibt einen (Typ-)Fehler

Bedingungen, Arithmetische Vergleiche


Die Infixoperatoren ==, <, >, <=, >=, /= haben den Typ:

Integer -> Integer -> Bool

Achtung: = ist reserviert fur Funktionsdefinitionen und let

Boolesche Ausdrucke

sind kombinierbar mit not, ||, && (nicht, oder, und)

Konstanten sind True, False.

Beispiel: 3.0 <= x && x < 5.0

Darstellungen eines Programms


sichtbare Syntax: vom Programmierer benutzt

Interne Syntax: “Linearisierung“; entzuckerte Version;

voll geklammert; alle Operatoren sind Prafix; kein Layout

Ableitungsbaum (Herleitungsbaum): Interne Darstellung;

Vom Kompiler erzeugt

Darstellungen eines Programms


Syntaxbaum:

Eindeutige Darstellung des Programms als markierter Baum.

Wird vom Compiler/Interpreter intern erzeugt.

Ermoglicht die eindeutige Definition

der Ausfuhrung des Programms.

Entspricht der hierarchischen Schachtelung des Programms.

Syntaxbaum: Beispiele


if x <= 0 then 1 else x*(quadrat (x-1))

ifThenElse

tthhhhhhhhhhhhhhhhhhhh

��++WWWWWWWWWWWWWWWWWWWWWWWWWW

<=

{{xxxxxxxxx

##FFFFFFFFF 1 ∗

xxqqqqqqqqqqqqqq

''PPPPPPPPPPPPPP

x 0 x app

wwooooooooooo

##FFFFFFFFF

quadrat −{{xxxxxxxxxx

��@@@

@@@@

@

x 1

Und zu x*(quadrat (x-1))

∗xxpppppppppppppp

((PPPPPPPPPPPPPP

x app

wwooooooooooo

##FFFFFFFFF

quadrat −{{xxxxxxxxxx

��@@@

@@@@

@

x 1

Syntaxbaum: Beispiele


Zwei Syntaxbaume zu 1-2-3:

−��

��

��

AAA

AAAA

1 −~~}}

}}}}

}}

��@@@

@@@@

2 3

(1− (2− 3))

−~~}}

}}}}

}

��???

????

?

−��~~

~~~~

~

AAA

AAAA

A 3

1 2

((1− 2)− 3)

Documents

Grundlagen der Programmierung 2 - Benutzer-Homepagesprg2/SS2011/folien/teil1/fol-1… · Grundlagen der Programmierung 2: Geplanter Inhalt der ersten H¨alfte Grundlagen der Programmierung