Einleitung

... [ Einführung in die funktionale Programmiersprache Haskell ] ... [ Thema Why functional programming matters ] ... [ Technische Aspekte ] ...

Übersicht: Einleitung

 

Ein grundsätzlicher Gedanke

Jeder Mensch ist Anhänger eines Stils, von dem er meint, es sei der wahre und schließe alle anderen Stile aus. Diese Stile werden zu starren Einrichtungen mit ihren Erklärungen des Weges. Sie verzerren und isolieren die Harmonie von Festigkeit und Sanftheit. Dafür errichten Sie rhytmische Formen als die festen Systeme ihrer Techniken.
 
Bruce Lee

Was ist unter funktionaler Programmierung zu verstehen ?

Bei der Klassifizierung von Programmiersprachen steht in der Regel der ihnen zugrundeliegende Denkansatz im Vordergrund. Je nachdem aus welcher Sichtweise das zu lösende Problem betrachtet wird können sich unter Einsatz bestimmter Sprachen Vereinfachungen und/oder Effektivierungen bei der Abbildung der zu lösenden Aufgabe ergeben.

Die zugrundeliegenden Denkansätze werden auch als Paradigmen bezeichnet. Hierbei gibt es vornehmlich folgende Unterscheidungen:

  • prozedurale oder imperative (Pascal, Cobol, C, Fortran, Basic,Comal, Pl/1,Ada83 )
  • funktionale (Haskell, Gofer, Lisp, Miranda, Hope)
  • objektorientierte (Java, C++, Smalltalk, Eiffel, Ada95)
  • deklarative (SQL)
  • regelbasierte (Prolog)
  • logische
Bei dem hier betrachteten funktionalen Ansatz liegt der der Gedanke zugrunde Programme in Form von mathematischen Funktionen zu beschreiben.
Eine Funktion verfügt über einen Definitionsbereich und einen Wertbereich. Ein funktionales Programm erhält somit stets Eingaben die seinem Definitionsbereich entsprechen und das zu lösende Problem darstellen. Ermittelt werden diejenigen Ausgabewerte die den Eingabewerten zugeordnet sind. Es wird also aus der mathematischen Sicht der Wert der Funktion berechnet. Ein auf den Grundsätzen funktionaler Programmiersprachen basierendes Programm lässt sich somit als eine komplexe Funktion auffassen. Diese Funktion enthält in aller Regel weitere Funktionen die nach bestimmten Regeln zur Funktionsbildung zusammengesetzt werden.

Welche bekannten Programmiersprachen basieren auf dem funktionalen Denkmuster

Die folgende Auflistung stellt eine Reihe der bekanntesten auf dem funktionalen Denkmuster basierenden Programmiersprachen dar:
 
Entstehung Name Entwickler Beschreibung
1958/1960 Lisp John McCarthy Listen als Grundstruktur
Bedingte Ausdrücke als Programme und Daten
Imperative (prozedurale) Anteile
1978 FP John Backus Polymorphes Typenkonzept
Variablenfreie Ausdrücke
Benutzerdefinierte Datenstrukturen
Pattern Matching (Parameterabhängige Funktionsdefinitionenauswahl)
1978 ML Robin Milner Leistungsfähiges Typkonzept 
Definition von abstrakten Datentypen
1985 Miranda John Turner Bedingt rekursive Gleichungen
Benutzerdefinierte Funktionale
Bedarfsgesteuerte Auswertungen (Lazy Evaluation)
1989 Haskell Paul Hudak Vollständige formale Semantik

Einfache Programmierbeispiele aus verschiedenen funktionalen Programmiersprachen

Anhand von einfachen Beispielen soll ein erster Eindruck von der Art und Weise der Formulierung von Programmen innerhalb von Funktionalen Programmiersprachen entstehen.
 

Problem Haskell Gofer Objective Caml Miranda
Hallo Welt 
module HelloWorld (main) where
main = putStr "Hello World\n"
 
show "Hello World"
 print_string("Hello World\n");;  
"Hello World!"
Fakultät fac 0 = 1 
fac n = n * fac (n-1) 		 fac :: Int -> Int 
fac 0 = 1 
fac n = n * fac(n-1) 		 letrec fac n = 
if n > 1 then n * fac (n-1) 
    else 1
 ;; 		 fac 0 = 1
fac 1 = 1
fac n = n * fac (n-1) 
Quicksort quicksort [] = []
quicksort (s:xs) = quicksort [x|x <- xs,x < s] 
++ [s] ++ quicksort [x|x <- xs,x >= s] 

qsort []    = []
qsort (a:x) = qsort [ b | b <- x; b<=a ]
              ++ [a] ++
              qsort [ b | b <- x; b>a ]

Ein weiteres gerne angeführtes Beispiel zur Verdeutlichung der Ausdruckskraft funktionaler Sprachen ist der Quicksortalgorithmus.
Im Folgenden sind 2 Implementierungen des Algorithmus zu sehen. Eine bezieht sich auf die funktionale Sprache Haskell und die andere auf die prozedurale Sprache 'C'.
 

Quicksort in Haskell Quicksort in C 
1. qsort []     = []
2. qsort (x:xs) = qsort kleiner_x ++ [x] ++ qsort groessergleich_x
                 where
                   kleiner_x   = [y | y <- xs, y < x]
                   groessergleich_x = [y | y <- xs, y >= x]

Implementierung:
1. Zeile:
Wird eine leere Liste sortiert, dann erhält man wieder eine leere Liste
2. Zeile:
Um eine Liste zu sortieren deren erstes Element 'x' ist und deren weiteren 
Elemente mit 'xs' bezeichnet werden, sortiere man die Liste der Elemente 
die kleiner als x sind "kleiner_x" und die Liste der Elemente die
 grössergleich x sind "groessergleich_x" getrennt und füge sie in der
 Mitte mit mit x wieder zusammen."
 

 qsort( a, lo, hi ) int a[], hi, lo;
{
  int h, l, p, t;
  if (lo < hi) {
  l = lo; h = hi; p = a[hi];

    do {
      while ((l < h) && (a[l] <= p))  l = l+1;
      while ((h > l) && (a[h] >= p)) h = h-1;
      if (l < h) {
          t = a[l];
          a[l] = a[h];
          a[h] = t;
      }
    } while (l < h);

    t = a[l]; a[l] = a[hi]; a[hi] = t;
    qsort( a, lo, l-1 );  qsort( a, l+1, hi );
  }
}

 
... [ Einführung in die funktionale Programmiersprache Haskell ] ... [ Thema Why functional programming matters ] ... [ Einleitung ] ... [ Technische Aspekte ] ...