Was ich an Rust so mag:

1. Null-Value und Fehlerbehandlung:

fn div(z: u32, n: u32) -> Result<u32> {
	let q = z / n;
	if  q * z != n {
		return Err("Kein ganzahliges Ergebnis!");
	}
	Ok(q)
}

#[test]
fn just_an_error() -> Result<u32> {
	let d: Result<u32> = div(32, 4);
	if d.is_ok() {
		assert_eq!(8, d.unwrap()); // 1
	}
	assert_eq!(8, d.unwrap_or(-1));    // 2
	assert_eq!(8, d?);                 // 3
	Ok(8)
}

Das Beispiel ist noch etwas ungelenk. Worum es mir geht, ist die Art wie ich / der Programmierer mit Fehlern umgehen muß.

1. Nach Prüfung, dass d kein Fehler ist, kann ich gefahrlos den Inhalt auspacken unwrap().
2. Wenn ich entweder den Inhalt oder einen Fallback haben möchte, empfiehlt sich unwrap_or()
3. Den Fehler an die nächsthöhere Instanz (=aufrufende Ebene) weiterdeligieren mit d? geht auch.

Das sind nur die offensichtlichen Wege. Es gibt natürlich viel mehr Möglichkeiten auf Fehler zu reagieren. Wichtig ist nur eins: Ich muß reagieren, ich kann den Fehler nicht ignorieren!

Vergleichbares gilt für Behandlung von NULL in Variablen.