Anhang: Keyword-Schnellreferenz

Alle Keywords auf einen Blick

Variablen:      nimm, fest
Werte:          wahr, falsch, nichts
Steuerfluss:    wenn, sonst, sonstwenn, solange, für, bis, schritt,
                wiederhole, in, springe, weiter, prüfe, fall, standard
Funktionen:     funktion, gib
Module:         nutze, teile
Logik:          und, oder, nicht, div
Klassen:        klasse, neu, dies, erbt, super, öffentlich, privat
Fehler:         versuche, fange, wirf

Hinweis: Typnamen wie Ganz, Text, Liste, Karte, Wahrheit sind keine Keywords, sondern eingebaute Typ-Konstanten (siehe „Typ-Konstanten" weiter unten). Du kannst sie z.B. mit typ(x) vergleichen.

kiste build versteht einen Ausschnitt der Sprache. Der Tree-Walker (kiste run) kann heute mehr als der native Compiler. Für die Keywords oben heißt das: Die meisten gelten in allen drei Pfaden, einige nicht.

Wenn du auf eine Lücke triffst, sagt Kiste es dir. Meist schon beim Bauen, mit einer Meldung, die den Ausweg nennt; bei manchen erst beim Laufen des fertigen Programms — in den Fällen, die wir kennen, meldet sich Kiste auch dort.

Am ehesten begegnen dir diese Stellen (Stand Kiste 0.10):

springe / weiter — Merk-Variable in der Bedingung (solange i < 9 und läuft) bzw. umgedrehte Bedingung (wenn nicht (i == 2))
2 in liste als Prüfung — liste.enthält(l, 2) (Abschnitt 18.5b), bei Text text.enthält("abc", "b"), bei Karten m["schlüssel"] != nichts
eine ganze Liste in einen Text schreiben ("{meine_liste}") — nimm die Elemente einzeln ("erste: {zahlen[0]}") oder bau den Text in einer Schleife zusammen
nimm [a, b] = liste — einzeln zuweisen: nimm a = l[0]
eine Klasse ohne eigenen neu-Konstruktor — schreib einen dazu, auch leer
wirf "Text" — eine eigene Fehlerklasse werfen (§11.8)

Das sind Beispiele, keine Aufzählung. Die verlässliche Auskunft gibt dir der Compiler, nicht diese Liste — und für die Standard-Bibliothek steht der Stand je Modul in §16.10.

Eingebaute Funktionen (Phase 1+)

I/O:
  sag(...)              Konsolen-Ausgabe
  frage(text)           Nutzereingabe einlesen

Reflektion:
  länge(x)              Grapheme-Anzahl (Text) / Listen-/Karten-/Bereichs-Länge — gibt ganz
  bytes_länge(text)     UTF-8-Bytes des Texts
  zeichen_länge(text)   Unicode-Codepoints des Texts
  typ(x)                Typ-Wert (vergleichbar mit Ganz/Dezimal/Komma/...)
  doku(x)               /// Doku-Kommentar von Funktion/Klasse/Modul

Konvertierung:
  als_ganz(x)           Zu ganz (schneidet ab Richtung Null)
  als_komma(x)          Zu komma (IEEE-754, kann Präzision verlieren)
  als_dezimal(x)        Zu dezimal (rundet komma auf 15 sig. Stellen)
  als_dezimal_exakt(k)  Zu dezimal, bit-genaue komma-Repräsentation
  als_text(x)           Display-Text
  als_wahrheit(x)       Strikt — nur wahr/falsch erlaubt

Rundung:
  runden(x)             Kaufmännisch (banker's rounding)
  runden(x, stellen)    Auf N Nachkommastellen
  aufrunden(x)          Richtung +∞
  abrunden(x)           Richtung -∞
  abschneiden(x)        Richtung Null

Numerischer Vergleich:
  fast_gleich(a, b, t)  |a-b| <= t — die richtige Wahl für komma

Sammlungen:
  kopiere(x)            Tiefe Kopie von Listen/Karten
  füge_hinzu(liste, x)  An Liste anhängen
  entferne_letztes(l)   Letztes Element entfernen (gibt es zurück)
  schluessel(karte)     Liste aller Karten-Schlüssel

Typ-Konstanten (Phase B.3.5+)

Ganz, Komma, Dezimal, Text, Wahrheit, Nichts,
Liste, Karte, Bereich, Funktion, Klasse, Modul, Typ

Operatoren

Arithmetisch:   +  -  *  /  %  ^   div  (Ganzzahl-Division)
Vergleich:      ==  !=  <  <=  >  >=
Zuweisung:      =  +=  -=  *=  /=  ??=  (B.5: Coalescing-Zuweisung)
Logik:          und  oder  nicht
Null-Safe:      ?.  (Safe-Member)   ??  (Coalesce)
Zugriff:        .   []   ()

Ende der aktuellen Version dieses Lernbuchs.

Es wird mit jeder Phase erweitert. Wenn du Fragen hast oder etwas unklar ist — sag Bescheid, dann ergänzen wir das hier.