Programmieren mit Funktionen

Seminar Programmiersprachen
03 | MetaLanguage (ML)
Name: Philipp Westrich
MetaLanguage (ML)
2
Agenda
1. Grundlagen der Sprache
1.1 Entstehungsgeschichte
1.2 Der Lambda-Kalkül
1.3 Syntax und Semantik
2. Wichtige Konzepte der Sprache
2.1 Programmieren mit Funktionen
2.2 Modulare und zustandsbehaftete Programmierung
2.3 Typdeklarationen
Kapitel 0
Agenda
3. Verwendung der Sprache
3.1 Erweiterungen
3.2 ML in der Praxis
Name: Philipp Westrich
MetaLanguage (ML)
3
Entstehungsgeschichte

1974 von Robin Milner als interaktives Beweissystem entwickelt.

Einflüsse:
LISP (Kern der Sprache)
ALGOL, COBOL (imperative Elemente)
Verwendung:

•
•
•
Zunächst begrenzt auf England (individuelle Implementierungen).
1990 Zusammenführung unterschiedlicher Konzepte zum
Standard of ML (SML).
1997 weltweite Verbreitung durch die Überarbeitung und
Erweiterung des Standards.
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
•
•
MetaLanguage (ML)
4
Einordnung
höhere Programmiersprachen
deklarative Sprachen
imperative Sprachen
funktionale Sprachen
Haskell, LISP, ML, …
Kapitel 1
Grundlagen der Sprache
ALGOL, C, Java, …
logische Sprachen
Prolog
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
MetaLanguage (ML)
5
Definition
Anliegen der funktionalen Sprache nach PEPPER:
„… der Versuch, etwas von der Eleganz,
Klarheit und Präzision der Mathematik in die Welt der
Programmierung einfließen zu lassen.“
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache

MetaLanguage (ML)
6

Um 1930 von Alonzo Church entwickelt.

Erlaubt die formale Beschreibung des Verhaltens von
Computerprogrammen.

mathematische Grundstein funktionaler Sprachen

Reduktionskalkül:
•
•
Legt das Verhalten von λ-Termen fest.
Beschreibt, wie ein λ-Term in einen anderen, gleichbedeutenden
überführt werden kann.
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
Der Lambda-Kalkül
MetaLanguage (ML)
7
Der Lambda-Term
allgemeine Form: (λx.e)

•
•
•
•
Vorspann λm,x,b bindet Variablen m, x, b an den Rumpf
Lexikalische Bindung: eine Variable gehört immer zur innersten
umschließenden Abstraktion
Stellt ausschließlich Funktionen dar, daraus Nachbildung von
Zahlen, boolesche Werte, etc.
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
Bsp: Geradengleichung in λ-Notation: (λm,x,b.mx+b)


x heißt Parameter der Abstraktion.
e wird als Rumpf bezeichnet.
MetaLanguage (ML)
8
Reduktionsregeln
2 Arten: α-Reduktion und β-Reduktion

•
•
können auf beliebige Teilausdrücke angewandt werden
Reduktionsreihenfolge beliebig (Satz von Church/ Rosser)
•
Benennt eine gebundene Variable in eine andere um.
β-Reduktion

•
•
Ersetzung aller Vorkommen eines Parameters durch den
Operanden einer Applikation (Anwendung der Applikation)
Unterschiedliche Auswertungsstrategien zur Wahl des zu
reduzierenden β-Redex.
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
α-Reduktion

MetaLanguage (ML)
9
Auswertungsstrategien
Generell bei rein funktionalen Sprachen egal, bspw:

•
•
leftmost-innermost reduction
call-by-need reduction (Haskell)
•
•
Festlegung aufgrund imperativer Elemente erforderlich
call-by-value (von innen nach außen)
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
Im Fall von ML

MetaLanguage (ML)
10
Syntax

Basiert auf vereinfachter Version der λ-Notation.

Für die direkte Kommunikation mit der Maschine entwickelt:
Standard Promt ‚-‘
Abschluss eines Ausdrucks mit ‚;‘
Beispiel:
Kapitel 1
Grundlagen der Sprache
•
•
•
- "Hello World!"; (* This is a commentary *)
val it = "Hello World!" : string

Ergebnisbezeichner : it

Typinferenz
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
MetaLanguage (ML)
11
Semantik
wohldefinierte Semantik:

•
•
Definition of Standard garantiert statische Sicherheit, d. h.
mehrdeutige oder undefinierte Ausdrücke existieren nicht.
dynamische Sicherheit durch Typüberprüfung zur Laufzeit.
•
•
statisch: Alle Werte einer Operation vom gleichen Typ.
strikt:
Auswertung von innen nach außen
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
Auswertung

MetaLanguage (ML)
12
Semantik

Dynamische Typprüfung

Kapitel 1
Grundlagen der Sprache
- 7 + 7.0;
Error: operator and operand don't agree [literal]
operator domain: int * int
operand:
int * real
in expression:
7 + 7.0
Strikte Auswertung
- fun cond(b,x,y) = if b then x else y;
- cond(true,1,1 div 0);
uncaught exception Div [divide by zero]
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
MetaLanguage (ML)
13
Typen
Standardtypen:

•
•
Integer, Fließkommazahlen (real), boolesche Werte und Strings
Tupel, Records, Listen
•
•
Ähneln dem Typ Enum in Haskell
null- und mehrstellige Konstruktoren
Funktionen

•
•
•
In funktionalen Sprachen ein Objekt wie jedes andere auch.
Können als Argument und Resultat einer Funktion auftreten oder in
einer Datenstruktur gespeichert werden.
In rein funktionalen Sprachen ohne Nebeneffekte.
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache
Benutzerdefinierte Typen:

MetaLanguage (ML)
14
Funktionsdefinititon
Eine Funktion ist ein Tripel ‹Df, Wf, Rf›, bestehend aus einer
Definitionsmenge Df , einer Wertemenge Wf und einer Relation
Rf aus Df х Wf, die Funktionsgraph genannt wird.

Der Funktionsgraph muss linkseindeutig sein, d. h. es gibt keine
zwei Paare ‹a, b1› є Rf und ‹a, b2› є Rf mit b1 ≠ b2.
Kapitel 1
Grundlagen der Sprache

Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
MetaLanguage (ML)
15
Funktionen in ML
Definition angelehnt an λ-Notation:
•
•
•
Anonyme Deklaration:
Kurzschreibweise:
Pattern Matching:
fn(x) => …
fun foo(x) = …
fun fac 0 = 1
| fac(n)= n*fac(n-1);
Currying:

•
•
Erzeugung einer neuen Funktion durch partielle Applikation.
Der Übergang von der Tupelbildung zum Funktionspfeil bezeichnet
man als currying.
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
Kapitel 1
Grundlagen der Sprache

MetaLanguage (ML)
16
Currying

Beispiel:
- fun abstractLine(a,b) x = a*x+b;
val abstractLine = fn : int * int -> int -> int
Kapitel 1
Grundlagen der Sprache
- val line = abstractLine(3,1);
val line = fn : int -> int
- line(5);
val it = 16 : int
Entstehungsgeschichte | Der Lambda-Kalkül | Syntax und Semantik
Name: Philipp Westrich
MetaLanguage (ML)
17
Programmieren mit Funktionen
•
•
•
Syntax begünstigt Implementierung von Lösungen
Elegante Lösungen möglich (Rekursion, higher-order functions)
Verzicht von Nebeneffekten begünstigt Validierung
Softwareprogramm aus funktionaler Sicht:

•
•
Nur eine (beliebig komplexe) Funktion
Referenzielle Transparenz erleichtert die Fehlersuche
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache
Vorteile des funktionalen Aspekts:

MetaLanguage (ML)
18

engl: higher-order functions

Funktionen generieren Funktionen
•
•

spart Programmieraufwand
besondere Form der Generalisierung, die über das Konzept in Java
hinausgeht
Beispiel: Potenzfunktionen
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache
Funktionen höherer Ordnung (1)
MetaLanguage (ML)
19
Funktionen höherer Ordnung (2)
Anstelle der mühsamen individuellen Definition…
fun
fun
|
fun
|
fun
|
...

plus (x,
times(_,
times(x,
power(_,
power(x,
super(_,
super(x,
y)
0)
y)
0)
y)
0)
y)
=
=
=
=
=
=
=
x + y;
0
plus(x, (times(x, (y-1))));
1
times(x, (power(x, (y-1))));
1
power(x, (super(x, (y-1))));
Erzeugung mittels Grundfunktion
- fun hyper (1) (x, y) = x + y
| hyper (2) (x, y) = x * y
| hyper (n) (x, y) = if y=0 then 1 else
hyper (n-1) (x , (hyper (n) (x, (y-1))));
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache

MetaLanguage (ML)
20
Funktionen höherer Ordnung (3)
Setzt man die Argumente x und y mit n gleich, erhält man eine
vereinfache ACKERMANN-Funktion:
- fun ackermann(n) = hyper(n)(n,n);
- ackermann(3); (* Is equivalent to 3^3 *)

Sie wächst stärker als jede primitiv-rekusive Funktion,
ackermann(4) hat bereits 10153 Dezimalstellen!

Sie eignet sich somit als Benchmark (ackermann(3,11)):
http://shootout.alioth.debian.org/gp4/benchmark.php?
test=recursive&lang=all#about
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache

MetaLanguage (ML)
21
Funktionen höherer Ordnung (4)
Laufzeit
C (GNU gcc)
2,36 sec
Java 1.4 (-server)
4,81 sec
SML (MLton)
7,97 sec
Haskell (GHC)
8,05 sec
Fortran (G95)
10.98 sec
Python (Psyco)
36.12 sec
Prolog (YAP)
111.65 sec
Ruby (JRuby)
11 min
PHP
14 min
Kapitel 2
Wichtige Konzepte der Sprache
Programmiersprache
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
MetaLanguage (ML)
22
Modularisierung (1)
•
•
Kapselung der Funktionalität und Beschränkung des Zugriffes nach
Außen.
Implementierung erfolgt versteckt.

Macht „Programmieren im Großen“ praktikabel.

Implementierung ähnelt dem Konzept der Interfaces in Java:
•
•

signature ist die Schnittstelle,
structure die Implementierung
SML ’97 kommt – ähnlich wie Java – mit vielen
vorimplementierten Bibliotheken.
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache
Konzept zur Strukturierung und Abgrenzung von Funktionen und
Datentypen

MetaLanguage (ML)
23
Modularisierung (2)

Beispiel:
Kapitel 2
Wichtige Konzepte der Sprache
signature Order = sig
val eq : 'a * 'a -> bool
val le : 'a * 'a -> bool
end
signature OrderedSequence = sig
type 'a Seq
val smaller : 'a Seq * 'a Seq -> bool
end
structure OrderedCharacters : Order = struct
fun eq(a,b) = … (* Implementation *)
fun le(a,b) = … (* Implementation *)
end;
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
MetaLanguage (ML)
24

ML ist keine rein funktionale Sprache

Einbettung imperative Elemente:
•
•

erleichterte Implementierung graphischer Algorithmen
essentiell für Beweissysteme
Beispiel:
fun hanoiIter(n) =
let …
val i = ref 0
in while !i < limit do (
…
i := !i +1
);
!result
end;
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache
Imperative Elemente
MetaLanguage (ML)
25
Typdeklaration
•
•
•
Ermöglicht abstraktere und allgemeingültigere Lösungen.
polymorphe Typen: Typdeklaration, die den Basistyp ihrer Elemente
als Parameter angibt.
polymorphe Funktion: mathematisch gesehen, eine Familie von
Funktionen
ML machte Polymorphie salonfähig:

•
•
•
keine strukturglobale Festlegung
individuell für Typen, Funktionen und Module
Lockerung des starren Typsystems
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache
Polymorphie:

MetaLanguage (ML)
26
Polymorphe Deklaration (1)

Beispiel: polymorphe Typen:
Kapitel 2
Wichtige Konzepte der Sprache
- datatype 'a Pair = pair of ('a * 'a);
datatype 'a Pair = pair of 'a * 'a
- val intPair = pair(1,1);
val intPair = pair (1,1) : int Pair
- val boolPair = pair(true,false);
val boolPair = pair (true,false) : bool Pair
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
MetaLanguage (ML)
27
Polymorphe Deklaration (2)
polymorphe Module:
•
•
Funktor: ermöglicht Parametrisierung von Modulen
Beispiel:
- functor OrdSeq (OrderedElements:Order):OrderedSequence =
struct
datatype ‘a Seq
= … (* Implementation *)
fun smaller (S1, S2) = … (* Implementation *)
end;
- structure Words = OrdSeq (OrderedCharacters); (* Usage *)
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache

MetaLanguage (ML)
28
Ambige Deklaration (1)
Standard Deklarationen:
•
•
Funktionen: monomorph oder polymorph
Variablen: monomorph, polymorph oder ambig
Ambige Deklaration

•
•
Behandelt freie Typvariablen monomorph, obwohl Polymorphie
möglich wäre.
Aufgrund der imperativen Elemente (Speicheroperationen)
benötigt
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache

MetaLanguage (ML)
29
Ambige Deklaration (2)
Beispiel:
- let val r = ref (fn x => x)
in r := (fn() => ());
1 + (!r 4)
end;
• Deklaration von r ambig, da rechte Seite Applikation
• zweite Zeile fordert r vom Typ (unit  unit) ref
• dritte Zeile vom Typ
(int  int) ref
 Fehlermeldung!
Programmieren mit Funktionen | Modulare und zustandsbehaftete Programmierung | Typdeklarationen
Name: Philipp Westrich
Kapitel 2
Wichtige Konzepte der Sprache

MetaLanguage (ML)
30
Erweiterungen des ’97 Standards

Nach 1997 keine neue offizielle Erweiterung für SML

Forschungseinrichtungen modifizieren SML, bspw:
•
•
Princeton University, Bell Laboratories : SML/NJ
(Vektoren, OR Muster, higher-order modules)
Uni Saarland: Alice ML
(parallele, verteilte und bedingte Programmierung)
INRIA: OCaml
(ML-Derivat für Objektorientierung)
Kapitel 3
Verwendung der Sprache
•
Erweiterungen | ML in der Praxis
Name: Philipp Westrich
MetaLanguage (ML)
31
Potential durch neue Features (Alice ML)
•
•
•
Auswertung der Argumente einer Funktion erst wenn sie benötigt
werden.
In Alice ML durch eigenen Typ realisiert: lazy futures
Durch lazy evaluation lässt sich das Konzept der higher-order
functions erweitern: Verknüpfung von Programmen
Constraint Programming

•
•
Benutzer beschreibt das Problem durch Bedingungen oder
Einschränkungen
Computer löst es selbstständig
Erweiterungen | ML in der Praxis
Name: Philipp Westrich
Kapitel 3
Verwendung der Sprache
Lazy Evaluation

MetaLanguage (ML)
32

Programme als Funktionen  Argument oder Resultat

Mit lazy evaluation neue Möglichkeiten der Modularisierung und
Terminierung

Beispiel:
•
•
•
Programme foo und bar im Ausdruck foo( bar( input))
Dabei wird bar erst gestartet, wenn foo versucht sein Argument
zu lesen.
Wenn foo fertig  automatische Terminierung von bar
(von außen)
Erweiterungen | ML in der Praxis
Name: Philipp Westrich
Kapitel 3
Verwendung der Sprache
Lazy Evaluation
MetaLanguage (ML)
33

Benutzer gibt Constraints vor

Computer belegt sukzessive Variablen mit Werten, bis
•
•
Ein Constraint verletzt
 Abbruch der Suche
Alle Variablen (erfolgreich)
belegt  eine Lösung gefunden
Erweiterungen | ML in der Praxis
Name: Philipp Westrich
Kapitel 3
Verwendung der Sprache
Constraint Programming (1)
MetaLanguage (ML)
34
Constraint Programming (2)
Beispiel: SEND + MORE = MONEY
import …;
fun money sp =
let val letters as #[S,E,N,D,M,O,R,Y] =
fdtermVec (sp, 8, [0`#9])
in distinct (sp, letters, FD.BND);
post (sp, S `<> `0, FD.BND);
post (sp, M `<> `0, FD.BND);
post (sp,
`1000`*S `+ `100`*E `+ `10`*N `+ D
`+
`1000`*M `+ `100`*O `+ `10`*R `+ E
`= `10000`*M `+ `1000`*O `+ `100`*N `+ `10`*E `+ Y,
FD.BND);
branch (sp, letters, FD.B_SIZE_MIN, FD.B_MIN);
{S,E,N,D,M,O,R,Y}
end;
Explorer.exploreAll money;
Erweiterungen | ML in der Praxis
Name: Philipp Westrich
Kapitel 3
Verwendung der Sprache

MetaLanguage (ML)
35
ML in der Praxis
Einsatzgebiete:
•
Beweissystem, zB:
−
−
−
•
Milner: LCF
TU München & Uni Cambridge: Isabelle
Motorola UK: Validierung von Message Sequence Charts
Kapitel 3
Verwendung der Sprache

Compilerbau, zB:
−
−
−
Implementierung der Tools Lex & YACC
NY University & Bell Laboratories: MLRisc
MLton
Erweiterungen | ML in der Praxis
Name: Philipp Westrich
MetaLanguage (ML)
36

Funktionale Sprache mit imperativen Elementen

strikt (call-by-value)

starres Typsystem, dynamisch durch Polymorphie

hohe mathematische Ausdruckskraft

modular, erweiterbar

Einsatzgebiete:
•
•
Kapitel 4
Zusmmenfassung
Zusammenfassung
Beweissystem,
Compilerbau
Name: Philipp Westrich