Datentypen verstehen

Kiste hat drei Zahl-Typen (ganz, komma, dezimal) plus text, wahrheit, liste, karte, funktion und nichts.

4.1 Die drei Zahl-Typen

Wichtig — das ist eine Stelle, an der Kiste sich von JavaScript und Python unterscheidet. JS hat einen einzigen Zahl-Typ (Float). Das führt zu berühmten Bugs wie 0.1 + 0.2 != 0.3 und Präzisionsverlust bei großen Zahlen. Kiste macht es richtig: drei klar getrennte Typen. (Siehe E-058 im Entscheidungs-Log.)

Typ	Wofür	Literal	Beispiel
ganz	Ganzzahlen, beliebig groß	42, 0xFF, 0b1010, 1_000_000	Schleifen, IDs, Bit-Operationen
dezimal	exakte Dezimalzahlen	3.14, 0.1, 1.99	Geld, Steuern, Mathe für Anwender
komma	IEEE-754 Float (näherungsweise)	1.99f, 42f, 1e6	Wissenschaft, Grafik, Wahrscheinlichkeit

4.1.1 Ganz (ganz)

Ganzzahlen — Standard:

nimm zaehler = 42
nimm minus_sieben = -7
nimm hex = 0xFF              // 255
nimm binaer = 0b1010         // 10
nimm gross = 1_000_000       // Unterstriche zur Lesbarkeit

Wichtig: Wie groß darf eine ganz-Zahl sein?

Die Antwort hängt vom Ausführungs-Pfad ab (siehe §1.2):

Pfad	Maximum	Verhalten bei Überlauf
kiste run (Tree-Walker)	beliebig groß	kein Überlauf, 2 ^ 100 rechnet exakt
kiste run --vm (VM)	beliebig groß	kein Überlauf, identisch zum Tree-Walker
kiste build (native)	i64-Bereich: -9_223_372_036_854_775_808 bis 9_223_372_036_854_775_807	Überlauf → Programm-Abbruch mit deutscher Fehlermeldung

// Tree-Walker und VM:
nimm riesig = 2 ^ 100        // funktioniert exakt
sag riesig                   // 1267650600228229401496703205376

// Native (kiste build):
nimm riesig = 2 ^ 100        // Compile-Error oder Laufzeit-Überlauf
//     "Überlauf in Ganz-Arithmetik bei * (Zeile X, Spalte Y)"

Wann kümmert dich das? In der Praxis fast nie — i64 reicht für $9.2 \times 10^{18}$ und damit für alle realistischen Zähler, IDs, Indizes, Mengen. Nur wenn du echte Big-Integer-Mathematik machst (Kryptographie, Berechnung mit sehr großen Zahlen), spürst du den Unterschied. Dann: bleib im Tree-Walker oder fang den Überlauf mit versuche/fange ab.

4.1.1a Schutz vor Überlauf im nativen Pfad

// Wenn du im kiste-build-Pfad mit potentiell großen Zahlen rechnest:
versuche {
    nimm produkt = a * b
    sag(produkt)
} fange e {
    sag("Zahl zu groß für Berechnung")
}

Im Tree-Walker fängt der versuche/fange nichts ab (weil kein Überlauf passiert). Im nativen Pfad fängt es genau den Überlauf-Throw ab. So bleibt dein Code in beiden Pfaden korrekt.

4.1.2 Dezimal (dezimal) — der Default für Kommazahlen

Exakte Dezimalrechnung, perfekt für Geld und alles, wo 0.1 + 0.2 == 0.3 gelten muss:

nimm preis = 1.99
nimm steuern = preis * 0.077
nimm gesamt = preis + steuern

sag 0.1 + 0.2          // 0.3 (exakt!)
sag 0.1 + 0.2 == 0.3   // wahr  ← darauf kann man sich verlassen

Merke: Eine Zahl mit Punkt ist standardmäßig dezimal. Du musst dazu nichts Besonderes schreiben.

4.1.3 Komma (komma) — Fließkomma für Wissenschaft

IEEE-754 Float64, schnell, aber näherungsweise. Markiert mit f-Suffix:

nimm geschwindigkeit = 1.99f       // explizit Komma
nimm lichtjahre = 1e6              // wissenschaftliche Notation → komma
nimm radius = 42f

Achtung: Mit komma gilt 0.1f + 0.2f != 0.3f (IEEE-754-Eigenheit). Verwende fast_gleich(a, b, toleranz) zum Vergleichen:

sag fast_gleich(0.1f + 0.2f, 0.3f, 0.0001f)   // wahr

kiste check warnt automatisch, wenn du == zwischen Komma-Werten benutzt.

4.1.4 Wann nehme ich was?

Frage	Antwort
Ganze Stückzahlen, IDs, Schleifen, Indizes?	ganz
Geld, Preise, Steuern, exakte Buchhaltung?	dezimal
Physik-Simulation, KI, 3D-Grafik, Wahrscheinlichkeiten?	komma (mit f-Suffix)
Du bist dir nicht sicher?	dezimal — der Default-Typ ist immer eine sichere Wahl

4.1.5 Typen mischen

Operation	Ergebnis
ganz + ganz	ganz
ganz + dezimal	dezimal (verlustfrei)
ganz + komma	komma
dezimal + dezimal	dezimal
komma + komma	komma
dezimal + komma	Fehler — explizit umwandeln

Die strikte Trennung von dezimal und komma ist Absicht: die beiden sind konzeptionell verschiedene Welten (exakt vs. näherungsweise) und sie zu mischen ist fast immer ein Bug. Wenn du wirklich konvertieren willst, mach es explizit:

nimm preis = 1.99
nimm messwert = 0.5f

// nimm gesamt = preis + messwert       // Fehler
nimm gesamt = preis + als_dezimal(messwert)  // ok

4.1.6 Division

Division gibt immer das präzisere Ergebnis — nie Ganzzahl-Truncation wie in C oder Python 2:

sag 5 / 2        // 2.5 (dezimal — kein 2!)
sag 5 / 2.0      // 2.5
sag 7.5f / 3f    // 2.5 (komma)

Wenn du wirklich Ganzzahl-Division willst, gibt es den div-Operator:

sag 5 div 2      // 2 (ganz)
sag 7 div 3      // 2

4.1.7 Konvertierung und Rundung

als_ganz(3.7)            // 3   (schneidet Richtung Null ab)
als_ganz(-3.7)           // -3
als_ganz("42")           // 42

als_dezimal(42)          // 42 als dezimal
als_dezimal("1.99")      // 1.99 als dezimal
als_dezimal(0.1f)        // 0.1 (gerundet auf 15 sig. Stellen)
als_dezimal_exakt(0.1f)  // 0.1000000000000000055... (bit-genau, für Diagnose)

als_komma(42)            // 42.0
als_komma(1.99)          // 1.99 als komma (kann Präzision verlieren!)

runden(2.5)              // 2 (kaufmännisch / banker's rounding)
runden(3.5)              // 4
runden(3.14159, 2)       // 3.14 (auf 2 Nachkommastellen)
aufrunden(2.1)           // 3
abrunden(2.9)            // 2
abschneiden(-2.7)        // -2 (Richtung Null)

4.2 Text (text)

Zeichenketten, immer in doppelten Anführungszeichen:

nimm gruß = "Hallo!"
nimm name = "Sascha"
nimm leerer_text = ""

Achtung: Einfache Anführungszeichen ('...') gibt es in Kiste nicht.

4.3 Wahrheit (wahrheit)

Nur zwei Werte: wahr oder falsch.

nimm ist_aktiv = wahr
nimm ist_fertig = falsch

4.4 Liste (liste)

Eine geordnete Sammlung von Werten:

nimm zahlen = [1, 2, 3, 4, 5]
nimm namen = ["Anna", "Bert", "Clara"]
nimm gemischt = [1, "zwei", wahr, 3.14]
nimm leer = []

Zugriff auf Elemente per Index (beginnt bei 0):

nimm farben = ["rot", "grün", "blau"]
sag farben[0]   // "rot"
sag farben[1]   // "grün"
sag farben[2]   // "blau"

4.5 Karte (karte)

Eine Sammlung von Schlüssel-Wert-Paaren:

nimm person = {
    "name": "Sascha",
    "alter": 38,
    "stadt": "Zürich"
}

sag person["name"]   // "Sascha"
sag person["alter"]  // 38

4.6 Funktion (funktion)

Funktionen sind Werte wie alles andere in Kiste:

nimm verdoppeln = funktion(x) {
    gib x * 2
}

sag verdoppeln(5)   // 10

Mehr dazu in Kapitel 8.

4.7 Nichts (nichts)

Der "leere" Wert — wenn etwas keinen Wert hat:

nimm noch_nicht_gesetzt = nichts

wenn noch_nicht_gesetzt == nichts {
    sag "Da ist nichts!"
}

Typ einer Variable herausfinden

typ(x) gibt einen Typ-Wert zurück (kein String!). Das macht Vergleiche tippfehler-sicher:

nimm x = 42
sag typ(x)             // ganz

nimm y = 1.99
sag typ(y)             // dezimal

nimm z = "Hallo"
sag typ(z)             // text

// Vergleichen mit Typ-Konstanten — sicher und IDE-freundlich:
wenn typ(x) == Ganz {
    sag "x ist eine Ganzzahl"
}

Verfügbare Typ-Konstanten: Ganz, Dezimal, Komma, Text, Wahrheit, Nichts, Liste, Karte, Bereich, Funktion, Klasse, Modul, Typ.

---