Einführung in Objective Caml Übung Konzepte der Programmiersprachen SS 2004 http://www.st.informatik.tu-darmstadt.de/static/pages/lectures/pl/ss04/assignments/index.html Einführung in Objective Caml Dipl.-Inf. Christoph Bockisch bockisch@informatik.tu-darmstadt.de Darmstadt University of Technology

Caml: Categorical Abstract Machine Language Übersicht ML: Meta-Language Funktionale Programmiersprache Automatische Speicherverwaltung Statische Typsicherheit (Fast) keine Seiteneffekte Pattern-Matching … Caml: Categorical Abstract Machine Language Gehört zur Sprachfamilie ML Basiert auf der Categorical Abstract Machine (CAM) Entwickelt seit 1987 am INRIA Institut, Frankreich Objective Caml (O‘Caml) seit 1996 Objekt-orientierte Features

Programmieren in O‘Caml O‘Caml System Zum Ausprobieren Read-Evaluate-Print Toplevel mit „ocaml“ aus Kommandozeile starten Oder O‘Caml Windows „Mysteriöse Fehler“ bei Copy & Paste wegen falscher Zeilenumbrüche O‘Caml Compiler Programm mit Editor schreiben Endung .ml Compiler „ocamlc“ aufrufen Programm „camlprog“ ausführen

O‘Caml Programmiersprache Kommentare eingeschlossen von (* und *) Kommentare können verschachtelt sein Bezeichner bestehen aus Zahlen, Buchstaben und _ Beginnen mit einem Kleinbuchstaben O‘Caml ist case-sensitiv Mit let können Konstanten definiert werden Funktionen sind Werte! Ein Ausdruck wird mit ;; beendet

Erste Gehversuche (O‘Caml System) Eingabe # 1 + 1 ;; - : int = 2 Typ Wert Name # let five = 5 ;; val five : int = 5 Ein benannter Wert # let succ n = n + 1 ;; val succ : int -> int = <fun> # succ five ;; - : int = 6 Funktionstyp Funktion als Wert

Erste Gehversuche (O‘Caml Compiler) Programm in Datei mit Endung .ml Nur Definitionen sichtbar, die weiter oben stehen Sequenz von Ausrücken: expr1; … ; exprn Wertet alle Ausdrücke der Reihenfolge nach aus Hat den Wert des letzten Ausdrucks expr1 bis exprn-1 sollten Typ unit haben ; nur zwischen zwei Ausdrücken (nicht danach) ;; beendet Ausdruck Nur benötigt, wenn von Compiler nicht feststellbar

Erste Gehversuche (O‘Caml Compiler) let succ n = n + 1 let rec add (a, b) = if a = 0 then b else succ (add (a - 1, b)) ;; print_string "5 + 6 = "; print_int (add (5, 6)) Compiler erkennt neuen Ausdruck wegen let Compiler erkennt neuen Ausdruck nicht selbst Sequenz Compiler erkennt neuen Ausdruck wegen Dateiende

string "", "One\nTwo\nThree" char 'a', '\n' Primitive Typen int 0, 5, 42, -17, 0x00FF Negative ints müssen (oft) eingeklammert werden: (-1) float 0.0, -5.3, 1.7e14, 1e-10 Dürfen nicht mit . anfangen bool true, false string "", "One\nTwo\nThree" char 'a', '\n'

Operatoren Arithmetische operatoren für ints: + - * / Arithmetische operatoren für floats: +. -. *. /. Es gibt keine implizite Typkonvertierung float_of_int int_of_char int_of_string (konvertiert "10" zu 10) … Vergleichoperatoren für Primitive: < <= = <> >= > Boole’sche Operatoren (shortcut Evaluierung): && || not

Operationen für string / char Konkatenation: ^ Das Modul String enthält weitere Funktionen zur Behandlung von strings String.length s String.index s c String.sub s p n String.uppercase s String.capitalize s

Einzelne Elemente durch ; getrennt Listentypen In [ ] eingeschlossen Einzelne Elemente durch ; getrennt Alle Elemente müssen denselben Typ haben Leere Liste: [] Beispiele: int list float list 'a list (wenn der Elementtyp unbekannt ist)

Operationen für Listen Element vorne an Liste anfügen: :: Zwei Listen verbinden: @ Das Modul List enthält weiter Funktionen List.hd l List.tl l List.length l List.nth l n

Durch ( ) eingeschlossen Die Elemente durch , getrennt Tupeltypen Durch ( ) eingeschlossen Die Elemente durch , getrennt Elemente können verschiedene Typen haben Anzahl der Elemente fest Beispiele: (int * int) (string * float * int list) Spezialfall Paare (pair) Funktionen fst und snd zum Zugriff auf erstes / zweites Element Weitere Funktionen durch Pattern-Matching Leeres Tupel: () oder unit

Recordtypen Definition: type {name1:typ1;…;namen:typn} Erzeugung von Records: let const={name1=val1;…;namen=valn} Zugriff auf Records: const.name1 Allgemein: expression.name

Parametrisierte Typen Definition: type ('a1 … 'an) name = typedef Beliebige Anzahl von Typvariablen als Tupel Typvariablen fangen mit ' an Ansonsten wie andere Bezeichner Typvariablen können in Typdefinition verwendet werden Beipiele: type 'param paired_with_int=int*'param;; 'a list

if … then … else Ausdruck Schreibweise: if boolean-expression then expression1 else expression2 Else-Teil wird benötigt, damit der Ausdruck immer einen Wert hat Then- und Else-Teil müssen denselben Typ haben Then-Teil wird nur ausgewertet, wenn die Bedingung true ist (umgekehrt für Else-Teil)

Definition von Funktionen Übernehmen ein Argument Geben einen Wert zurück Argument und Rückgabewert Können Tupel sein (mehrere Werte) Können unit sein (kein Wert) Mit let rec werden rekursive Funktionen definiert and verknüpft let Definitionen Können sich gegenseitig sehen Auswerten einer Funktion: function_name argument

let / let rec / and let factorial n = let rec factorial n = if n = 0 then 1 else n*(factorial n–1) ;; let rec factorial n = if n = 0 then 1 else n*(factorial n–1) let ping n = if n > 0 then pong n–1; else () let pong n = if n > 0 then ping n–1; ;; let rec ping n = if n > 0 then pong (n - 1) else () and pong n = if n > 0 then ping (n - 1) ;;

Anonyme Funktionen Definition: (fun argument -> expression)

Die Ausdrücke expr1 bis exprn müssen denselben Typ haben match match Ausdruck: match expr with pattern1 -> expr1 | … | patternn -> exprn Die Ausdrücke expr1 bis exprn müssen denselben Typ haben Die Patterns sollten alle möglichen Fälle abdecken Sonst Warung vom Compiler Die Patterns werden in angegebener Reihenfolge getestet

Generalized Assignment # let (a, b, c) = (8, 3, 6);; val a : int = 8 val b : int = 3 val c : int = 6 # let (x::xs) = [1;2;3;4];; (* Non-exhaustive match warning deleted *) val x : int = 1 val xs : int list = [2; 3; 4]

Generalized Assignment auch in Patterns Pattern-Matching Generalized Assignment auch in Patterns Das Pattern (x :: xs) entspricht einer nicht leeren Liste # let rec listSize the_list = match the_list with [] -> 0 | (x::xs) -> 1 + listSize xs;;

Higher-Order Funktionen Eine First-Order Funktion ist eine Funktion, deren Argument und Wert “Daten” sind Bei einer Second-Order Funktion ist Argument oder Wert eine First-Order Funktion Eine Higher-Order Funktion hat beliebige Funktionen als Argument oder Wert O’Caml unterstützt Higher-Order Funktionen

Wenn der Typ nicht bestimmbar ist, wird Typvariable eingesetzt Typinferenz Der O‘Caml Compiler kann an Funktionsdefinitionen erkennen, welchen Typ Argument und Ergebnis haben Wenn der Typ nicht bestimmbar ist, wird Typvariable eingesetzt Die Funktion heißt dann „polymorph“ Nicht zu verwechseln mit Polymorphie bei OO Sprachen

Integeraddition: Operanden und Ergebnis müssen ints sein Typinferenz Integeraddition: Operanden und Ergebnis müssen ints sein # let add (a, b) = a + b;; val add : int * int -> int = <fun> Listenoperationen: Operanden und Ergebnis müssen Listen sein # let rec reverse the_list = match the_list with [] -> [] | h :: t -> reverse t @ [h];; val reverse : 'a list -> 'a list = <fun> Elementtypen sind gleich

Erwartet Wert von Typ unit. Nur unit selbst hat den Wert. Ein- / Ausgabe Funktionen, die auf die Konsole schreiben print_int arg print_string arg … print_newline () Funktionen, die von Tastatur lesen read_line Hat einen string als Rückgabewert Modul Printf Erwartet Wert von Typ unit. Nur unit selbst hat den Wert. # print_newline () ;; - : unit = ()

Referenzen Objective Caml Homepage: http://www.ocaml.org/ Komplette Dokumentation und Referenz: „Developing Applications with Objective Caml“, E. Chailloux, P. Manoury, B. Pagano, O’Reilly: http://caml.inria.fr/oreilly-book/html/ Kurze Einführung und Zusammenfassung: „A Concise Introduction to Objective Caml“, D. Matuszek: http://www.csc.vill.edu/~dmatusze/resources/ ocaml/ocaml.html Tutorial: „A C++/Java Programmer’s introduction to Objective Caml“, S. Houben: http://caml.inria.fr/FAQ/stephan.html Geschichte von Caml: http://www.pps.jussieu.fr/~cousinea/Caml/ caml_history.html

Aufgabe 1 (Bearbeitung bis 30.4.): Übung 1 Aufgabe 1 (Bearbeitung bis 30.4.): O‘Caml Dokumentation lesen Übungsaufgaben daraus bearbeiten Können Sie Muster formulieren, wie bestimmte Problemstellungen gelöst werden? Oder Coding-Styles?

Aufgabe 2 (Bearbeitung bis 30.4.): Übung 1 Aufgabe 2 (Bearbeitung bis 30.4.): O‘Caml wertet Ausdrücke „eager“ aus: Das Gegenteil ist eine „lazy“ Auswertung: Beweisen Sie dass O‘Caml eager auswertet Verwenden Sie nach Möglichkeit keine Seiteneffekte let mult (x, y) = x * y;; mult (1 + 2, 3 + 4) mult (3, 3 + 4) mult (3, 7) 3 * 7 21 mult (1 + 2, 3 + 4) (1 + 2) * (3 + 4) 3 * (3 + 4) 3 * 7 21

Übung 1 Aufgabe 2.a) Wie kann „lazy“ Auswertung dennoch erzwungen werden? Benutzen Sie nicht das Schlüsselwort lazy und Modul Lazy Funktion und Argument dürfen angepasst werden Bonusaufgabe: Ein Bonus-Prozentpunkt für Korrekte Bearbeitung Kurze (5 – 10 Min.) Präsentation Eingereicht bis 29.4. An bockisch@informatik.tu-darmstadt.de

Aufgabe 3 (Bearbeitung bis 30.4.): Übung 1 Aufgabe 3 (Bearbeitung bis 30.4.): Gegeben sind Funktionsdefinitionen Bestimmen Sie den Typ der Funktionen Bestimmen Sie, welche Funktionen partiell sind Geben Sie für partielle Funktionen ein Beispiel an, das nicht akzeptiert wird.

Aufgabe 4 (Bearbeitung bis 7.5.): Übung 1 Aufgabe 4 (Bearbeitung bis 7.5.): Programmieren Sie ein Mancala Spiel S1 F0 F1 F2 F3 F4 F5 G S2

Aufgabe 4, Zusatzaufgabe: Übung 1 Aufgabe 4, Zusatzaufgabe: Intelligenter Computerspieler Implementierung des Negamax-Algorithmus vorgegeben

Übung 1 Das Übungsblatt mit weiteren Quellen und weitere Materialien können heruntergeladen werden: http://www.st.informatik.tu-darmstadt.de/ static/pages/lectures/pl/ss04/assignments/index.html