<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="https://doc.seolizer.de/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="https://doc.seolizer.de/feed.php">
        <title>SEOLizer Dokumentation - lyx_-_programmiersprache:sprache</title>
        <description></description>
        <link>https://doc.seolizer.de/</link>
        <image rdf:resource="https://doc.seolizer.de/_media/wiki:dokuwiki.svg" />
       <dc:date>2026-09-12T15:13:48+00:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:abi-calling-conventions?rev=1788587359&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:arrays?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:attributes-pragmas?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:bedingungen?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:capabilities?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:datentypen?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:enums?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:exception-handling?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:exit-codes?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:ffi?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:funktionen?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:generics-traits?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:handles-und-fd?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:memory-management?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:module-und-importe?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:oop?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:pattern-matching?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:pointer-inlining?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:rekursion?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:rohspeicher?rev=1786540435&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:schleifen?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:std-fehlerkonventionen?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:syntax?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:threads?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:typaliase-und-typumwandlung?rev=1788880062&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:variablen?rev=1788880062&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="https://doc.seolizer.de/_media/wiki:dokuwiki.svg">
        <title>SEOLizer Dokumentation</title>
        <link>https://doc.seolizer.de/</link>
        <url>https://doc.seolizer.de/_media/wiki:dokuwiki.svg</url>
    </image>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:abi-calling-conventions?rev=1788587359&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-05T05:49:19+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – ABI &amp; Calling Conventions</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:abi-calling-conventions?rev=1788587359&amp;do=diff</link>
        <description>Lyx – ABI &amp; Calling Conventions

Die ABI (Application Binary Interface) legt fest, wie Funktionen auf Binärebene kommunizieren: welche Register Argumente tragen, wie der Stack aufgebaut ist, wer Register sichert und wie der Rückgabewert transportiert wird. Lyx folgt den nativen Konventionen der jeweiligen Zielplattform, um Kompatibilität mit Betriebssystem-Syscalls und C-Bibliotheken ohne Wrapper zu gewährleisten.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:arrays?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Arrays, Maps &amp; Datensammlungen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:arrays?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Arrays, Maps &amp; Datensammlungen

Lyx unterscheidet vier Container-Formen. Die Wahl zwischen ihnen ist keine Stilfrage, sondern eine Sicherheits- und Architekturentscheidung: Stack-Arrays sind deterministisch und DO-178C-tauglich, Heap-Arrays sind flexibel aber nicht echtzeitfähig, SIMD-Arrays für numerische Hochleistungsberechnungen, Maps für Schlüssel-Wert-Zugriff.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:attributes-pragmas?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Attribute &amp; Pragmas (@-Referenz)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:attributes-pragmas?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Attribute &amp; Pragmas (@-Referenz)

Attribute (auch Pragmas genannt) sind Compiler-Anweisungen, die mit @ beginnen und vor einer Deklaration stehen. Sie steuern Optimierungen, Sicherheits-Verifikation, Speicherlayout und FFI-Verhalten. Attribute verändern nie die Semantik des Programms für korrekte Eingaben — sie sind Zusatzinformationen für den Compiler, nicht für den Laufzeit-Interpreter.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:bedingungen?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Bedingungen (if / else / match)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:bedingungen?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Bedingungen (if / else / match)

Bedingungen steuern den Kontrollfluss in Lyx. Sie erlauben es, Codeblöcke nur dann auszuführen, wenn eine bestimmte logische Voraussetzung erfüllt ist.

→ Schleifen · Pattern Matching · Sprachsyntax

----------

1. Grundlegende Syntax

Eine</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:capabilities?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Capabilities (LCBS)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:capabilities?rev=1788880062&amp;do=diff</link>
        <description>Capabilities (LCBS)

Lyx bindet jedes Programm an ein Capability-Modell: Der Compiler erzeugt aus den deklarierten Berechtigungen einen seccomp-Filter, der zur Laufzeit jeden nicht angeforderten Systemaufruf hart abbricht. Das Modell ist Zero-Privilege mit Default-Deny</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:datentypen?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Datentypen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:datentypen?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Datentypen

Stand: V1.0.21A

	&quot; Globale Arrays und Structs tragen seit lyxc 1.0.17C (#1256, #1299). Auf Modulebene deklarierte Aggregate verhalten sich jetzt wie lokale: var q: [8]int64; nimmt einen schreibenden Indexzugriff an, ein Initialisierer (</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:enums?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Enums — Aufzählungstypen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:enums?rev=1788880062&amp;do=diff</link>
        <description>Enums — Aufzählungstypen

Ein enum definiert einen Typ, dessen gültige Werte eine abgeschlossene, benannte Menge bilden. Der Compiler kennt alle Werte zur Compile-Zeit — das ist die Grundlage der Exhaustivitätsprüfung in match: Wird ein Enum-Wert nicht behandelt, ist es ein</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:exception-handling?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Fehlerbehandlung</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:exception-handling?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Fehlerbehandlung

Lyx setzt nicht auf Exceptions. Das ist eine bewusste Designentscheidung: Exceptions erzeugen nicht-linearen Kontrollfluss, der zur Compile-Zeit schwer nachzuverfolgen ist, WCET-Analysen erschwert und in sicherheitskritischen Systemen verboten ist.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:exit-codes?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Exit-Codes</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:exit-codes?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Exit-Codes

Der Exit-Code ist die einzige Information, die ein beendetes Programm seinem Aufrufer maschinenlesbar hinterlässt. Alles andere — Meldungen, Logs, Reports — muss gelesen werden; der Exit-Code lässt sich abfragen. Plattformübergreifend gilt eine einzige feste Regel:</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:ffi?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Foreign Function Interface (FFI)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:ffi?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Foreign Function Interface (FFI)

Das Foreign Function Interface ruft C-Funktionen aus Lyx auf. Die Grundlage ist die C-ABI der Zielplattform: System V AMD64 auf Linux/macOS, AAPCS64 auf ARM64.

	&quot; Philosophie: Die Units in std/ und data/ kommen ohne externe C-Bibliotheken aus. FFI ist für Fälle gedacht, in denen eine vorhandene C-Bibliothek genutzt werden soll.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:funktionen?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Funktionen (vertieft)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:funktionen?rev=1788880062&amp;do=diff</link>
        <description>Funktionen (vertieft)

Funktionen sind der zentrale Baustein jedes Lyx-Programms. Diese Seite geht über die Grunddeklaration hinaus und behandelt Tupel-Rückgaben, anonyme Funktionen, Funktionstypen, Higher-Order Functions und den Pipe-Operator.

	&quot;</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:generics-traits?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Generics &amp; Interfaces</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:generics-traits?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Generics &amp; Interfaces

Lyx kennt zwei Formen der Abstraktion über Typen: generische Funktionen, die für jeden eingesetzten Typ eigenen Code erzeugen (Monomorphisierung), und Interfaces, die eine gemeinsame Schnittstelle für verschiedene Klassen festlegen.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:handles-und-fd?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Handle-Konzept: Warum alles ein int64 ist</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:handles-und-fd?rev=1788880062&amp;do=diff</link>
        <description>Handle-Konzept: Warum alles ein int64 ist

In der Lyx-Standardbibliothek ist fast jeder Ressourcentyp ein int64. Eine TCP-Verbindung ist ein int64. Ein PDF-Dokument ist ein int64. Eine PostgreSQL-Verbindung ist ein int64. Ein SQLite (Datenbanken &amp; SQL)-Statement ist ein</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:memory-management?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Memory Management</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:memory-management?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Memory Management

Lyx hat keinen Garbage Collector. Das ist keine Einschränkung — es ist ein Designziel. GC-Pausen sind nicht-deterministisch: Sie können jederzeit einsetzen, beliebig lange dauern und Echtzeitgarantien zerstören. In eingebetteten Systemen, Flugsteuerungen und Hochlast-Servern ist vorhersagbares Speicherverhalten keine Option, sondern Pflicht.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:module-und-importe?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Module und Import-System</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:module-und-importe?rev=1788880062&amp;do=diff</link>
        <description>Module und Import-System

Jede Lyx-Quelldatei ist gleichzeitig ein Modul (in Lyx-Terminologie: eine Unit). Die Unit-Deklaration am Dateianfang legt den Namensraum fest. import lädt eine andere Unit und macht ihre öffentlichen Symbole sichtbar. pub steuert, welche Symbole exportiert werden.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:oop?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Objektorientierte Programmierung</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:oop?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Objektorientierte Programmierung

Lyx unterscheidet bewusst zwischen zwei Arten von benutzerdefinierten Typen: Structs und Klassen. Diese Trennung ist kein Stilmittel — sie macht die Performance-Implikationen im Code sichtbar. Ein Struct liegt auf dem Stack, ein Klassenobjekt auf dem Heap. Ein Struct-Aufruf ist ein direkter Funktionsaufruf, ein virtueller Methodenaufruf geht durch eine V-Table. Beides ist in Lyx explizit und damit für den Entwickler kontrollierbar.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:pattern-matching?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Pattern Matching</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:pattern-matching?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Pattern Matching

match ist das zentrale Kontrollfluss-Element für Fallunterscheidungen in Lyx. Es ist typsicher, exhaustiv — der Compiler prüft, ob alle möglichen Werte abgedeckt sind — und wird vom Backend oft zu einer Jump-Table optimiert, die schneller ist als eine if/else-Kette.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:pointer-inlining?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Low-Level: Speicherzugriff &amp; Pragmas</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:pointer-inlining?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Low-Level: Speicherzugriff &amp; Pragmas

Systemprogrammierung – Treiber, Kernel-Module, Echtzeit-Regler, Hardware-Abstraktionen – erfordert direkten Zugriff auf Speicheradressen. Lyx löst das ohne Zeigertypen: Eine Adresse ist ein gewöhnlicher</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:rekursion?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Rekursion</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:rekursion?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Rekursion

Rekursion ist ein Kontrollfluss-Muster, bei dem eine Funktion sich selbst aufruft, um ein Problem schrittweise auf einen einfacheren Fall zu reduzieren. Lyx unterstützt Rekursion auf allen Zielplattformen (x86_64, ARM64, RISC-V64) und bietet spezielle Werkzeuge zur Begrenzung und Verifikation des Stack-Verbrauchs – eine Voraussetzung für zertifizierungspflichtige Software nach DO-178C.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:rohspeicher?rev=1786540435&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-08-12T13:13:55+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Rohspeicher: alloc, peek &amp; poke</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:rohspeicher?rev=1786540435&amp;do=diff</link>
        <description>Rohspeicher: alloc, peek &amp; poke

Die gesamte Lyx-Standardbibliothek arbeitet auf einer einzigen Speicherabstraktion: alloc(n) liefert einen rohen Byte-Puffer als int64-Adresse, peek8/poke8 lesen und schreiben einzelne Bytes, peek64/poke64 lesen und schreiben 8-Byte-Wörter. Kein GC, keine versteckten Allokationen, kein Overhead.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:schleifen?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Schleifen (Loops)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:schleifen?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Schleifen (Loops)

Lyx bietet drei Schleifenformen für unterschiedliche Anwendungsfälle: while für bedingungsgesteuerte Schleifen, for für Zählschleifen mit bekanntem Bereich und repeat-until für fußgesteuerte Schleifen. Für sicherheitskritischen Code ergänzt das</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:std-fehlerkonventionen?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Fehler-Konventionen der Standardbibliothek</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:std-fehlerkonventionen?rev=1788880062&amp;do=diff</link>
        <description>Fehler-Konventionen der Standardbibliothek

Die Lyx-Standardbibliothek wirft keine Exceptions und kennt keine impliziten Fehlerzustände. Jede Funktion, die fehlschlagen kann, signalisiert das über ihren Rückgabewert — immer sichtbar, immer explizit. Diese Seite erklärt die vier Konventionen, die sich quer durch alle std-Units ziehen. (Die Sprache selbst kennt</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:syntax?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Syntax-Referenz</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:syntax?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Syntax-Referenz

Diese Seite ist die vollständige Syntax-Referenz für Lyx. Sie beschreibt alle lexikalischen Regeln, Operatoren, Kontrollstrukturen und Deklarationsformen. Für konzeptuelle Erläuterungen und Code-Beispiele zu einzelnen Themen existieren eigene Unterseiten (verlinkt am Ende jedes Abschnitts).</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:threads?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Threads &amp; Nebenläufigkeit</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:threads?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Threads &amp; Nebenläufigkeit

Lyx unterstützt Nebenläufigkeit über POSIX-Threads (pthreads), gekapselt in der Unit std.thread. Sie bietet sechs Primitive: Thread (Ausführungsfaden), Mutex (gegenseitiger Ausschluss), Cond (Bedingungsvariablen),</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:typaliase-und-typumwandlung?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Typ-Aliase und Typumwandlung</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:typaliase-und-typumwandlung?rev=1788880062&amp;do=diff</link>
        <description>Typ-Aliase und Typumwandlung

Lyx hat ein explizites Typsystem: Implizite Konvertierungen gibt es nicht. Jede Typumwandlung muss mit dem as-Operator geschrieben werden. Typ-Aliase über type benennen vorhandene Typen neu — entweder als einfaches Alias, als Range-Typ mit Wertebereichseinschränkung oder als neuen Struct-/Class-Typ.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:sprache:variablen?rev=1788880062&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-09-08T15:07:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Variablen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:sprache:variablen?rev=1788880062&amp;do=diff</link>
        <description>Lyx – Variablen

Eine Variable in Lyx ist immer drei Entscheidungen zugleich: Speicherklasse (darf sie sich ändern?), Typ (was steht drin?) und Ort (lokal oder auf Modulebene?). Diese Seite geht den Lebenszyklus durch — Deklaration, Initialisierung, Gültigkeit, Lebensdauer — und sammelt die Stellen, an denen der Compiler heute anders reagiert, als man erwartet.</description>
    </item>
</rdf:RDF>
