typinferenz

Typinferenz (Typableitung)

Kurz: Bei der Typinferenz ermittelt der Compiler die Datentypen selbst aus dem Zusammenhang, sodass man sie nicht überall hinschreiben muss – ohne die Sicherheit der statischen Typprüfung aufzugeben.

Genauer: Aus let x = 5 folgt int, aus x + 1.5 folgt float. Der Compiler prüft weiterhin alle Typen vor dem Start. Die Technik ist in Haskell, OCaml und F# am weitesten entwickelt (Hindley-Milner-Verfahren) und steckt in var/auto (Java, C#, C++), val (Kotlin, Scala), let (Rust, Swift), := (Go) und TypeScript.

Im Detail

let x = 5;                      // i32
let y = 2.5;                    // f64
let namen = vec!["Mia", "Tom"]; // Vec<&str>
let laenge = namen.len();       // usize
// let z = x + y;               // Fehler: i32 + f64 geht nicht

alter := 17                // int
preis := 9.99              // float64
name := "Mia"              // string

const zahlen = [1, 2, 3];                  // number[]
const verdoppelt = zahlen.map((n) => n * 2); // number[]

quadrat x = x * x          -- Typ wird abgeleitet: Num a => a -> a

Grenzen

• An Schnittstellen (öffentliche Funktionen) notiert man Typen bewusst; sie dienen als Dokumentation.
• Bei mehrdeutigen Fällen (leere Liste, null) verlangt der Compiler eine Angabe.
• Typinferenz ist kein dynamisches Typisieren: In Python steht der Typ erst zur Laufzeit fest (Typsysteme).

Der Gewinn: weniger Schreibarbeit, Refactoring bleibt sicher, und Fehler wie "5" + 3 fallen schon beim Übersetzen auf. Siehe auch Type Casting und Generics.

Siehe auch: Type Casting, Generics, var-Schlüsselwort, Typsysteme