Typisierung (Informatik)

Eine Typisierung (engl. typing) dient in der Informatik dazu, dass die Objekte (hier Objekte im mathematisch-abstrakten Sinne verstanden) der Programmiersprachen, wie z. B. Variablen, Funktionen oder Objekte (im Sinne der objektorientierten Programmierung) korrekt verwendet werden. Das Hauptziel ist die Vermeidung von Laufzeitfehlern.

Dies wird durch Typsysteme erreicht, die eine Idee aus der Mathematik, speziell der Typentheorie aufgreifen, die durch die Entdeckung von Widersprüchen in der Mengenlehre in eine Grundlagenkrise geraten war, bis man sich darauf besann, genauer darauf zu achten, welche Objekte wie benutzt werden.

Typsystem

Der Begriff Typsystem bezeichnet in der Informatik eine Komponente, die in Programmiersprachen zum Einsatz kommen kann, um den Wertebereich von Variablen einzuschränken. Programmiersprachen, die über ein Typsystem verfügen, nennt man typisiert. Je nach Ausprägung des Typsystems spricht man gelegentlich auch von stark typisierten oder schwach typisierten Sprachen. Durch die Typisierung soll sichergestellt werden, dass auf den Inhalten von Variablen keine Operationen ausgeführt werden, die syntaktisch oder semantisch fehlerhaft sind. Ein Typsystem wird durch folgende Bestandteile gebildet:

• Die Typen selbst, die entweder mittels Typdefinitionen erzeugt oder in der jeweiligen Sprache fest integriert (als primitive Datentypen) sind.
• Die Möglichkeit, Programmelemente (wie Variablen, Methodenparameter usw.) mittels Typannotation mit einem bestimmten Typ zu deklarieren.
• Regeln, nach denen die Werte von Ausdrücken einem bestimmten Typ zugeordnet werden.
• Regeln zur Prüfung der Typkorrektheit von Zuweisungen.
• Optional weitere Sprachbestandteile wie typbezogene Operatoren (z. B. „instanceof“ in diversen Sprachen) oder eine Reflection API zur Ermittlung und Prüfung von Typinformation zur Laufzeit.

Klassifizierung von Typsystemen

Typsysteme lassen sich entlang dreier Dimensionen klassifizieren:

• starke Typisierung (strong typing) und schwache Typisierung (weak typing)

Wie streng unterscheidet die Sprache die Typen? Welche Datentypen können ineinander umgewandelt werden? Erlaubt sie implizite Typumwandlungen? Erlaubt sie unsichere Typumwandlungen, z.B. bei denen Werte verloren gehen können?

• dynamische Typisierung (dynamic typing) und statische Typisierung (static typing)

Typprüfungen können zur Übersetzungszeit oder zur Laufzeit vorgenommen werden. Im ersten Fall spricht man von statischer Typprüfung, im zweiten von dynamischer Typprüfung. Grundsätzlich sind statische Typprüfungen wünschenswert, da sie Laufzeitfehler ebenso wie möglicherweise schwer auffindbare Folgefehler ausschließen.

• explizite Typisierung (explicit typing) und implizite Typisierung (implicit typing)

Werden die Datentypen explizit genannt oder per Typableitung ermittelt?

Zu den Aufgaben eines Typsystems gehören:

• Erkennung von Typverletzungen bei der Übersetzung und Ausführung. Die Typinformation kann dabei als eine redundante Information aufgefasst werden, die verhindert, dass Variablen Werte zugewiesen werden, welche die betreffende Variable niemals annehmen sollte (sogenannte Typinvarianten). Sie verhindert so die Ausführung von Operationen auf den Inhalten dieser Variablen, die entweder unmöglich oder aus programmlogischen Gründen nicht sinnvoll ist.
• Typumwandlung (engl. type conversion), also Umwandlung bzw. Beförderung und Degradierung von Typen (engl. type promotion, type demotion). In vielen objektorientierten Sprachen stehen hierfür die drei Möglichkeiten up cast, down cast und cross cast zur Verfügung.

Beispiele

Die folgenden Beispiele sollen die Klassifizierung verdeutlichen; die Einordnung von Sprachen in diese Kategorien ist aber bis zu einem gewissen Grad subjektiv (C++ z. B. ist stärker typisiert als C, aber schwächer als OCAML), und viele Typsysteme haben je nach Verwendung mehrere Aspekte (Polymorphe Werte, Typumwandlung etc.).

Statisch, implizit, stark: OCAML

 let myAdd a b =   (* Wir definieren eine Funktion, die zwei nicht näher bezeichnete Werte nimmt *)
   a +. b;;        (* +. ist der Additionsoperator für Gleitkommazahlen *)
 (* val myAdd : float -> float -> float = <fun> *)
 (* Ocaml hat von selbst erkannt, dass diese Funktion zwei Gleitkommazahlen erwartet und eine zurückgibt *)
 myAdd 1 2.5;; (* Addiere zwei Zahlen, aber eine davon ist eine Ganzzahl *)
 (* '''Compilerfehler:''' This expression has type int but is here used with type float *)
 myAdd (float_of_int 1) 2.5;; (* Addiere zwei Zahlen, wandle Ganzzahl zuvor in Gleitkommazahl um, ergibt 3.5 *)
 
 
 let x = object method a = 10 end;; (* definiere ein Objekt mit einer Methode a, die den Wert 10 zurückgibt*)
 let y = object method a = 10 method b = 11 end;; (* definiere ein Objekt mit zwei Methoden a und b, die jeweils unterschiedliche Ints zurückgeben.*)
 let l = [x;(y :> <a:int>)];; (* speichere x und y in einer Liste. y wird dabei in den Typ von x umgewandelt*)

Statisch, explizit, schwach: C

 int x;           // Weise x explizit den Typ int (Ganzzahl) zu.
 printf("%f", x); // Gib x als Gleitkommazahl aus (ohne Umwandlung, Ergebnis undefiniert,
                  // eventuell Programmabbruch)

Dynamisch, implizit, schwach: PHP

 $x = 1;                  // Weise x explizit den Wert 1 zu (und damit implizit den Typ int).
 $x = 2 + "42";           // Addiere eine Zahl und eine Zeichenkette,
                          // wandle dazu die Zeichenkette in eine Zahl um
 // $x ist jetzt 44
 $x = 2 + "Ich bin keine Zahl";  // Wie oben, ungültige Zeichenkette wird zu 0 umgewandelt
 // $x ist jetzt 2

Dynamisch, implizit, stark: Python

 x = 1             # Weise x explizit den Wert 1 zu (und damit implizit den Typ int).
 x = 2 + "42"      # Addiere eine Zahl und eine Zeichenkette, Laufzeitfehler ("TypeError")
 x = 2 + int("42") # Addiere eine Zahl und eine Zahl, die aus einer Zeichenkette erstellt wird
 # x ist jetzt 44
 x = 2 + int("Ich bin keine Zahl") # Laufzeitfehler ("ValueError")

Statisch und dynamisch, explizit, stark: Pike

 int x = 1;        // Definiere x als int und weise explizit den Wert 1 zu.
 x = 2 - "42";     // Subtrahiere eine Zeichenkette von einer Zahl, Kompilier- oder Laufzeitfehler ("Bad argument 2 to `-.")
 x = "42";         // Weise x den wert "42" zu. Kompilierfehler ("Bad type in assignment")
 x = 2 + (int)"42"; // Addiere eine Zahl und eine Zahl, die aus einer Zeichenkette erstellt wird
 // x ist jetzt 44
 x = 2 + (int)"Ich bin keine Zahl" // Ungültige Zeichenkette wird zu 0 umgewandelt
 // x ist jetzt 2

Siehe auch

• Duck Typing
• Datentyp
• Programmanalyse
• Typsicherheit

Literatur

• Cardelli, Luca: Type Systems in The Computer Science and Engineering Handbook, Allen B. Tucker (Ed.), chapter 103, pp. 2208-2236, CRC Press, Boca Raton, FL, 1997. (online)
• Pierce, Benjamin: Types and Programming Languages, MIT Press, 2002

Weblinks

• About static vs. dynamic typing, and strong vs. weak typing (englisch)