Standard-Bibliothek — `liste`

Verfügbar — implementiert in Phase B.6.2. Vollständige Spec in docs/liste.md.

Listen sind in jedem Programm überall: Einkaufslisten, Messreihen, Highscore-Tabellen, Suchergebnisse. Das liste-Modul gibt dir die Standard-Werkzeuge: Prüfen, Hinzufügen, Sortieren, Filtern, Abbilden, Aggregieren, Zusammenfügen.

18.1 Aktivieren

nutze liste

nimm xs = [3, 1, 4, 1, 5, 9, 2, 6]
sag liste.länge(xs)        // 8
sag liste.summe(xs)        // 31
sag liste.maximum(xs)      // 9

18.2 Die Konvention: immutabel vs. mutiert

Das ist die wichtigste Regel des liste-Moduls (und ab E-063 für die ganze Stdlib): die Funktionen kommen paarweise.

Gibt eine neue Liste zurück (Adjektiv/Partizip)	Verändert die Originale (Imperativ)
`sortiert`	`sortiere`
`gefiltert`	`filtere`
`umgekehrt`	`kehre_um`
`eingefügt`	`füge_ein`
`entfernt`	`entferne`
`angehängt`	`hänge_an`
`vorangestellt`	`stelle_voran`
`geflacht`	`flache`
`einzigartig`	`entferne_duplikate`

Faustregel: Endet die Funktion auf -t / -en / -ig (Adjektiv-Form), bekommst du eine neue Liste und das Original bleibt unverändert. Endet sie auf -e / -eh (Imperativ), wird die Liste direkt geändert — und die Funktion gibt nichts zurück.

nimm xs = [3, 1, 2]

// Variante 1: Original bleibt, neue Liste zurück
nimm sortiert = liste.sortiert(xs)
sag xs           // [3, 1, 2]   ← unverändert
sag sortiert     // [1, 2, 3]

// Variante 2: xs wird direkt umsortiert
liste.sortiere(xs)
sag xs           // [1, 2, 3]   ← jetzt sortiert

Warum das paarweise? Weil die Anfänger-Frage „verändert das jetzt meine Variable oder nicht?" eine eindeutige Antwort am Funktionsnamen verdient. JavaScript .sort() mutiert UND gibt das Array zurück — verwirrend. Python hat sorted() und list.sort() mit verschiedenen Aufruf-Stilen — auch verwirrend. Kiste ist symmetrisch.

18.2b Anlegen in einem Schlag: `liste.gefüllt(n, startwert)`

nutze liste
nimm puffer = liste.gefüllt(1024, 0.0f)   // 1024 × 0.0
nimm reihe  = liste.gefüllt(10, 0)        // 10 × 0 (Spielfeld-Zeile!)

Baut eine Liste mit n Kopien von startwert — statt einer hänge_an-Schleife. n < 0 wirft einen fangbaren Fehler; startwert muss ein Grundwert sein (ganz, komma, wahrheit oder text). Listen oder Karten als Startwert lehnt Kiste bewusst ab: gefüllt(5, []) würde fünfmal dieselbe innere Liste speichern — änderst du eine, ändern sich „alle fünf". Verschachtelte Strukturen baust du mit einer Schleife.

Build-Bonus: Eine gefüllt-Liste bleibt im nativen Compiler typrein (liste<komma> statt liste<beliebig>) — puffer[i] lesen und schreiben kostet Nanosekunden. Details in Kapitel 33.7.

18.3 Higher-Order: `gefiltert`, `abgebildet`, `gesammelt`

Diese drei Funktionen nehmen eine andere Funktion als Argument (deshalb „higher-order"):

// gefiltert: behält nur Elemente, für die fn(x) wahr ergibt
nimm gerade = liste.gefiltert([1, 2, 3, 4, 5], funktion(x) {
    gib x % 2 == 0
})
sag gerade        // [2, 4]

// abgebildet: wandelt jedes Element um
nimm verdoppelt = liste.abgebildet([1, 2, 3], funktion(x) { gib x * 2 })
sag verdoppelt    // [2, 4, 6]

// gesammelt: faltet die Liste zu einem einzigen Wert (Reduce / Fold)
nimm produkt = liste.gesammelt([1, 2, 3, 4], 1, funktion(akku, x) {
    gib akku * x
})
sag produkt       // 24

Mit Index? gefiltert und abgebildet akzeptieren auch eine 2-Parameter-Funktion funktion(element, index) { ... }:

nimm beschriftet = liste.abgebildet(["a", "b", "c"], funktion(x, i) {
    gib "{i}: {x}"
})
sag beschriftet   // ["0: a", "1: b", "2: c"]

18.4 Sortieren mit eigenem Vergleicher

nimm wörter = ["Apfel", "Birne", "Kirsche"]

// Default: lexikografisch (Byte-Reihenfolge)
sag liste.sortiert(wörter)
// ["Apfel", "Birne", "Kirsche"]

// Nach Länge sortieren
nimm nach_länge = liste.sortiert(wörter, funktion(a, b) {
    gib länge(a) - länge(b)
})
sag nach_länge
// ["Apfel", "Birne", "Kirsche"]   ← Birne und Apfel beide 5 Buchstaben → stabile Reihenfolge

Die Vergleichs-Funktion gibt zurück:

< 0: a kommt vor b
0: gleich
> 0: a kommt nach b

sortiert und sortiere sind stabil — gleiche Werte behalten ihre relative Reihenfolge.

18.5 Aggregation

nimm zahlen = [10, 20, 30, 40]
sag liste.summe(zahlen)      // 100
sag liste.minimum(zahlen)    // 10
sag liste.maximum(zahlen)    // 40
sag liste.mittel(zahlen)     // 25  (eigentlich 25.0 als dezimal)

Zwei wichtige Regeln:

liste.summe([]) → 0 (sinnvoller Default).
liste.minimum([]), liste.maximum([]), liste.mittel([]) → Fehler. Wer „leer" als legitim verstehen will, prüft vorher mit liste.leer(xs).

Nicht verwechseln mit mathe.minimum / mathe.maximum! Die mathe-Variante nimmt mehrere einzelne Argumente (mathe.maximum(3, 7, 2)), die liste-Variante nimmt eine ganze Liste (liste.maximum([3, 7, 2])). Verschiedene Welten, beide sinnvoll.

18.6 Negative Indizes und Slicing

Wie überall in Kiste sind negative Indizes erlaubt — -1 ist das letzte Element:

nimm xs = [10, 20, 30, 40, 50]
sag liste.entfernt(xs, -1)        // [10, 20, 30, 40]   ← letztes raus
sag liste.scheibe(xs, -2, -1)     // [40, 50]            ← die letzten zwei
sag liste.erste_n(xs, 3)          // [10, 20, 30]
sag liste.letzte_n(xs, 2)         // [40, 50]

18.7 Gruppierung

nimm wörter = ["Apfel", "Birne", "Avocado", "Banane"]
nimm nach_anfangsbuchstabe = liste.gruppiert(wörter, funktion(w) {
    gib w[0]
})
sag nach_anfangsbuchstabe
// {"A": ["Apfel", "Avocado"], "B": ["Birne", "Banane"]}

liste.gruppiert(l, fn) gibt eine karte zurück — Schlüssel sind die fn-Ergebnisse, Werte sind Listen der Elemente, die zu diesem Schlüssel gehören.

18.8 Zusammenfügen und Zip

sag liste.verbunden([1, 2], [3, 4])
// [1, 2, 3, 4]

sag liste.gezippt([1, 2, 3], ["a", "b", "c"])
// [[1, "a"], [2, "b"], [3, "c"]]

sag liste.gezippt_mit([1, 2, 3], [10, 20, 30], funktion(a, b) { gib a + b })
// [11, 22, 33]

gezippt schneidet auf die kürzere Liste zu — keine Fehler bei unterschiedlicher Länge.

18.9 Was nicht in `liste` ist

zufall_element und gemischt leben im zufall-Modul (Kap. 17). Listen-Operationen, die Saat brauchen, gehören dorthin.
parallel_abgebildet — kommt mit Nebenläufigkeit.
tabelle-Operationen (mehrere Spalten, JOIN-artiges) — eigene Phase wert.
Sliding-Window fenster(l, n) — kann später additiv kommen.