Funktionen

Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Funktionen
• Mengentheoretische Sicht: Eine Funktion ist eine spezielle
Art von Menge
• Alternative Sicht: Eine Funktion ist eine Berechnung
• Church entwickelte dazu das 6-Kalkül als allgemeine
Notation für Funktionen und Berechnungen.
• Funktionen höherer Ordnung: Funktionen, deren
Argumente Funktionen sind:
F(f) = f 1 f
Für f(x) = x + 1 ist F(f)(x) = x + 2 bzw. F(f)(1) = 3.
Funktionen als Programme 1
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
6-Notation für Funktionen
• "Übliche" Notation für Funktionen wird schnell
unübersichtlich
• 6-Notation schafft Abhilfe:
Eine Funktion, die x in x2 abbildet, wird geschrieben als:
6x . x2
Eine Funktion, die eine Funktion in die Komposition der
Funktion mit sich selbst abbildet, wird geschrieben als:
6f . f 1 f
• Funktionen können damit "namenlos" geschrieben
werden.
Funktionen als Programme 2
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
6-Kalkül
• ,-Konversion: 6x . P(x) = 6y . P(y)
Der Name der gebundenen Variablen ist unwichtig.
• --Reduktion: (6x . P(x))(a) = P(a)
Die einzige "Rechenregel" für das 6-Kalkül.
Beispiele:
(6x . x2)(2) = 22 = 4
2
2
2
4
(6f . f 1 f)(6x . x ) = 6x . x 1 6x . x = 6x . x
((6f . f 1 f)(6x . x2))(2) = (6x . x2 1 6x . x2)(2) = (6x . x4)(2) =
16
((6x . 6y . x + y )(4))(5) = (6y . 4 + y)(5) = 4 + 5 = 9
Funktionen als Programme 3
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Funktionale Programmiersprachen
• Die Grundrechenregeln sind Funktionen.
• Grundlage ist immer das 6-Kalkül.
• Dazu kommen andere "Elemente": Typensysteme, Typen,
Module, usw.
• Beispiele: Lisp, Haskell, Miranda, Standard ML
Funktionen als Programme 4
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Standard ML
• Interaktiv
• Starkes Typensystem
• Polymorphes Typensystem
• Unterstützt abstrakte Typen
• Typeninferenz
• Statischer Skopus von Identifier
• Unterstützt Module
• Unterstützt "pattern matching"
• Formale Definition
Funktionen als Programme 5
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Interaktion
• Inputprompt -, Abschluss mit ;, Output markiert mit >
- 3+2;
> 5 : int
• Fehlererkennung: Parse error, run-time error, type clash
- 3 +;
- 3 div 0;
- 3 + true;
Funktionen als Programme 6
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Typen
• Eingebaute einfache Typen: unit, bool, int, string, real
• Eingebaute zusammengesetzte Typen:
1. Tupel
- (true, ());
> (true,()) : bool * unit
2. Listen
- [];
> [] : ‘a list
- [1,2];
> [1,2] : int list
3. Records
• Typeninferenz: Der Typ muss nicht explizit angegeben
werden, wenn er eindeutig ist.
• Zusammengesetze Typen sind Polytypen:
Wenn ‘a und ‘b Typen sind, dann sind auch ‘a list und
‘a * ‘b Typen.
Funktionen als Programme 7
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Identifiers
• Bindung von Werten an Namen, damit Resultate nicht
"verloren" gehen:
- val x = 4*5;
> val x = 20 : int
- val s = "abc" ^ "def";
> val s = "abcdef" : string
- val pair = ( x, s );
> val pair = (20, "abcdef") : int * string
Funktionen als Programme 8
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Pattern matching
• Automatisch Zerlegung von zusammengesetzten Werten
- val x = (17, true);
> val x = (17, true) : int * bool
- val (left, right) = x;
> val left = 17 : int
val right = true : bool
- val mylist = [1, 2, 3];
> val mylist = [1, 2, 3] : int list
- val [x,y,z] = mylist;
> val x = 1 : int
val y = 2 : int
val z = 3 : int
- val hd::tl = mylist
> val hd = 1 : int
val tl = [2, 3] : int list
Funktionen als Programme 9
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Funktionen
• Funktionen werden definiert, in dem sie ebenfalls an
Identifier gebunden werden.
- fun twice x = 2*x;
> val twice = fn : int -> int
- twice 4;
> 8 : int
• Funktionen können rekursiv sein.
- fun fact x = if x = 0 then 1 else x * fact(x - 1);
> val fact = fn : int -> int
- fact 5;
> 120 : int
• Funktionen können Fallunterscheidungen machen.
- fun append([],l) = l
| append(hd::tl,l) = hd::append(tl,l);
> val append = fn : (‘a list * ‘a list) - > ‘a list
Funktionen als Programme 10
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Funktionen mit mehreren Argumenten
• Die Funktion append ist eine Funktion mit einem
Argument, einem Tupel.
• Funktionen können auch mehrere Argumente haben.
- fun times (x:int) (y:int) = x * y
> val times = fn : int -> (int -> int)
- fun twice = times 2;
> val times = fn : int -> int
- twice 4;
> 8 : int
- times 3 4;
> 12 : int
Funktionen als Programme 11
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Funktionen mit Funktionen als Argumente
• Beispiel: Die Funktion, die eine andere Funktion auf alle
Elemente einer Liste anwendet.
- fun map f [] = []
map f (hd::tl) = f(hd) :: map f tl ;
> val map fn : (‘a ->‘b) - > (‘a list) -> (‘b list)
- val l = [1,2,3,4,5];
> val l = [1,2,3,4,5] : int list
- map twice l;
> [2,4,6,8,10] : int list
- fun listify x = [x];
> val listify = fn : ‘a - > ‘a list
- map listify l;
> [[1],[2],[3],[4],[5]] : int list list
Funktionen als Programme 12
Formale Grundlagen der Informatik (Fuchs/Kraan SS 99)
Funktionen mit Funktionen als Argumente
(2)
• Beispiel: Komposition von Funktionen
- fun compose(f, g) (x) = f(g(x));
> val compose = fn : ((‘a ->‘b) * (‘c ->‘a)) -> (‘c ->‘b)
- val funny = compose(listify, twice);
> val funny = fn : int -> int list
- funny 5;
> [10] : int list
Funktionen als Programme 13