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.

→ Einführung: Erste Schritte · Syntax: Sprachsyntax · Methoden: OOP & Klassen · Generics: Generics & Interfaces

fn Add(a: int64, b: int64): int64 {
    return a + b;
}

• Rückgabetyp steht nach dem Doppelpunkt hinter der Parameterliste.
• Kein Rückgabewert: Rückgabetyp weglassen (implizit void); return ohne Wert oder ganz weglassen.
• pub macht eine Funktion aus anderen Units importierbar.

// Kein Rückgabewert
fn Log(msg: pchar) {
    PrintLn(msg);
}

// Öffentlich sichtbar (exportiert)
pub fn GetVersion(): pchar {
    return "1.0.0";
}

Alle Funktionen ohne pub sind privat — sie sind nur innerhalb derselben Unit sichtbar. Das ist die strenge Voreinstellung; explizites Exportieren verhindert unkontrollierte Kopplung zwischen Modulen.

Ein Parameter kann einen Vorgabewert erhalten. Wird das Argument beim Aufruf weggelassen, setzt der Compiler den Vorgabewert ein. Der Wert muss zur Compile-Zeit feststehen.

fn Verbinde(host: pchar, port: int64 = 8080, timeout: int64 = 30): int64 {
    // ...
    return 0;
}

Verbinde("localhost");            // port = 8080, timeout = 30
Verbinde("localhost", 9000);      // timeout = 30
Verbinde("localhost", 9000, 5);   // alle Werte explizit

Benannte Argumente erlauben eine freie Reihenfolge:

fn F(a: int64, b: int64 = 5): int64 { return a - b; }

F(b: 3, a: 10);   // 7 — Reihenfolge frei, weil benannt
F(10, b: 3);      // 7 — positional und benannt gemischt

Ein Struct-Parameter ist ein Wert. Die Funktion bekommt beim Eintritt eine Kopie; Änderungen daran bleiben in der Funktion. Das entspricht der Zuweisung, die seit 1.0.20A ebenfalls kopiert.

Wer das Original des Aufrufers ändern will, sagt das mit ref:

type Punkt = struct { x: int64; y: int64; }

fn AlsWert(p: Punkt): void    { p.x := 99; }   // wirkt nur auf die Kopie
fn AlsRef(ref p: Punkt): void { p.x := 99; }   // wirkt auf das Original

fn main(): int64 {
    var p: Punkt;
    p.x := 1;
    AlsWert(p);  PrintLn("nach AlsWert: ", IntToStr(p.x));
    AlsRef(p);   PrintLn("nach AlsRef:  ", IntToStr(p.x));
    return 0;
}

nach AlsWert: 1
nach AlsRef:  99

ref ist ein weiches Schlüsselwort: es gilt nur unmittelbar vor einem Parameternamen mit folgendem Doppelpunkt. Ein Parameter, der schlicht ref heißt (fn F(ref: int64)), und eine Variable var ref := 5 bleiben zulässig.

Funktionen können mehr als einen Wert zurückgeben, indem der Rückgabetyp als Tupel angegeben wird. Das ersetzt Out-Parameter und verhindert, dass Fehlerinformationen über Ausnahmen transportiert werden müssen.

fn Divide(a: int64, b: int64): (int64, bool) {
    if (b == 0) { return (0, false); }
    return (a / b, true);
}

Rückgabetyp: (int64, bool) — ein Tupel aus zwei Typen.
Rückgabewert: (Ausdruck1, Ausdruck2) — beide Werte in runden Klammern, kommagetrennt.

unit main;
import std.io;
import std.string;

fn Divide(a: int64, b: int64): (int64, bool) {
    if (b == 0) { return (0, false); }
    return (a / b, true);
}

fn main(): int64 {
    var result, ok := Divide(10, 3);
    if (ok) {
        PrintLn(IntToStr(result));  // 3
        PrintLn("");
    }

    // Kurzform ohne explizite Typangabe — Typen werden inferiert
    var q, ok2 := Divide(7, 0);
    if (ok2 == false) {
        PrintLn("Division durch null");
    }

    return 0;
}

Ein Tupel trägt höchstens zwei Werte — die Aufrufkonvention gibt zwei Register her (rax, rdx). Drei Elemente werden abgewiesen:

fn Drei(): (int64, int64, int64) { return (1, 2, 3); }
// sema error: Tupel mit mehr als zwei Elementen

Für mehr Werte ein Struct zurückgeben — das ist ohnehin die lesbarere Form, weil die Felder benannt sind:

type Koordinate = struct {
    lat:   f64;
    lon:   f64;
    valid: bool;
};

fn ParseCoord(input: pchar): Koordinate {
    var k: Koordinate;
    k.lat := 48.137;
    k.lon := 11.576;
    k.valid := true;
    return k;
}

Beim Entpacken steht die Form ohne Klammern: var a, b := F();. Die geklammerte Schreibweise var (a, b) := F(); gibt es nicht.

Lyx erlaubt Funktionsliterale — also Funktionen ohne Namen, die direkt als Ausdruck geschrieben werden. Sie folgen der gleichen Syntax wie benannte Funktionen, tragen aber keinen Bezeichner.

fn(param1: Typ1, param2: Typ2): RückgabeTyp {
    return ...;
}

import std.io;

fn Apply(value: int64, transform: fn(int64): int64): int64 {
    return transform(value);
}

fn main(): int64 {
    var result: int64 := Apply(21, fn(x: int64): int64 {
        return x * 2;
    });
    PrintLn(IntToStr(result));  // 42
    PrintLn("");
    return 0;
}

Eine anonyme Funktion kann mit let oder var gebunden werden:

unit main;
import std.io;
import std.string;

fn main(): int64 {
    let double: fn(int64): int64 := fn(x: int64): int64 {
        return x * 2;
    };

    let greet: fn(pchar): void := fn(name: pchar): void {
        PrintLn(StrConcat("Hallo, ", name));
    };

    PrintLn(IntToStr(double(21)));  // 42
    greet("Lyx");                   // Hallo, Lyx
    return 0;
}

Zum Erfassen der Umgebung: Anonyme Funktionen greifen auf Variablen des umgebenden Scope zu — anders als frühere Fassungen dieser Seite behaupteten. Der Wert wird dabei zum Definitionszeitpunkt übernommen; eine spätere Änderung wirkt nicht mehr:

var n: int64 := 100;
var f := fn(x: int64): int64 { return x + n; };
n := 1;
f(5);        // 105, nicht 6

Für Safety-kritischen Code (DO-178C, MISRA) bleibt die Empfehlung, Zustand ausdrücklich als Parameter zu übergeben — die versteckte Abhängigkeit besteht hier real, sie wird nur nicht verhindert.

Ein Funktionstyp beschreibt die Signatur einer Funktion — welche Parameter sie nimmt und welchen Typ sie zurückgibt. Mit type lässt sich ein benannter Alias für einen Funktionstyp anlegen.

type TypName = fn(Param1Typ, Param2Typ): RückgabeTyp;

// Vergleichsfunktion für zwei int64-Werte — gibt Ordnung zurück
type Comparator = fn(a: int64, b: int64): int32;

// Transformationsfunktion: int64 → int64
type Transformer = fn(value: int64): int64;

// Ereignis-Handler ohne Rückgabewert
type EventHandler = fn(event_id: int32, data: int64): void;

Benannte Typen verbessern die Lesbarkeit von Parameterlisten erheblich:

// Ohne Alias — schwer zu lesen
fn Sort(arr: int64, n: int64, cmp: fn(int64, int64): int32): void { ... }

// Mit Alias — sofort klar
type Comparator = fn(a: int64, b: int64): int32;
fn Sort(arr: int64, n: int64, cmp: Comparator): void { ... }

Benannte Funktionen können überall dort übergeben werden, wo ein passender Funktionstyp erwartet wird — einfach durch Angabe des Namens ohne ():

unit main;
import std.io;
import std.string;

type Comparator = fn(a: int64, b: int64): int32;

fn CompareAsc(a: int64, b: int64): int32 {
    if (a < b) { return -1; }
    if (a > b) { return  1; }
    return 0;
}

fn CompareDesc(a: int64, b: int64): int32 {
    return CompareAsc(b, a);   // Reihenfolge getauscht
}

fn main(): int64 {
    var cmp: Comparator := CompareAsc;   // Funktion als Wert
    PrintLn(IntToStr(cmp(3, 7) as int64));  // -1

    cmp := CompareDesc;
    PrintLn(IntToStr(cmp(3, 7) as int64));  // 1

    return 0;
}

Eine Higher-Order Function (HOF) ist eine Funktion, die eine andere Funktion als Parameter entgegennimmt oder eine Funktion als Ergebnis zurückgibt.

Der Parameter wird mit dem Präfix fn und dem Funktionstyp deklariert:

fn paramName: fn(ArgTyp): RückgabeTyp

import std.io;

// Apply: wendet transform auf value an und gibt das Ergebnis zurück
fn Apply(value: int64, transform: fn(int64): int64): int64 {
    return transform(value);
}

// Für jeden Index in [0, n) callback aufrufen
fn ForEach(n: int64, callback: fn(int64): void): void {
    var i: int64 := 0;
    while (i < n) limit(1000000) {
        callback(i);
        i := i + 1;
    }
}

// Akkumuliert f(i) für alle i in [0, n)
fn Accumulate(n: int64, initial: int64, fold: fn(int64, int64): int64): int64 {
    var acc: int64 := initial;
    var i: int64 := 0;
    while (i < n) limit(1000000) {
        acc := fold(acc, i);
        i := i + 1;
    }
    return acc;
}

fn Square(x: int64): int64  { return x * x; }
fn PrintIdx(i: int64): void { Print(IntToStr(i)); Print(" "); }
fn Sum(acc: int64, val: int64): int64 { return acc + val; }

fn main(): int64 {
    PrintLn(IntToStr(Apply(7, Square)));  // 49
    PrintLn("");

    ForEach(5, PrintIdx);            // 0 1 2 3 4
    PrintLn("");

    PrintLn(IntToStr(Accumulate(5, 0, Sum)));  // 0+1+2+3+4 = 10
    PrintLn("");

    return 0;
}

Funktionsparameter lassen sich mit Generics kombinieren:

fn MapApply<In, Out>(value: In, transform: fn(In): Out): Out {
    return transform(value);
}

fn main(): int64 {
    var doubled: int64 := MapApply<int64, int64>(21, fn(x: int64): int64 {
        return x * 2;
    });
    PrintLn(IntToStr(doubled));  // 42
    PrintLn("");
    return 0;
}

→ Ausführliche Generics-Syntax: Generics & Interfaces

Funktionstypen lassen sich in Arrays speichern — das ist das Lyx-Äquivalent einer vtable ohne Klassen:

type Handler = fn(data: int64): void;

fn OnConnect(data: int64): void    { Print("connect\n"); }
fn OnDisconnect(data: int64): void { Print("disconnect\n"); }
fn OnMessage(data: int64): void    { Print("message\n"); }

con CONNECT:    int64 := 0;
con DISCONNECT: int64 := 1;
con MESSAGE:    int64 := 2;

fn main(): int64 {
    var dispatch: [3]Handler := [OnConnect, OnDisconnect, OnMessage];

    var event: int64 := MESSAGE;
    if (event >= 0 & event < 3) {
        var h: Handler := dispatch[event];   // erst in eine Variable
        h(0);                                 // dann aufrufen  -> message
    }

    return 0;
}

std.thread erwartet den Funktionszeiger als int64. Das ist die einzige Ausnahme von der typisierten Übergabe — es liegt an der C-POSIX-Schnittstelle unter der Haube:

import std.thread;
import std.io;

fn Worker(arg: int64): int64 {
    PrintLn("Thread läuft");
    return 0;
}

fn main(): int64 {
    var t: Thread := ThreadCreate(Worker as int64, 0);
    ThreadJoin(t);
    return 0;
}

→ Vollständige Thread-Dokumentation: Threads & Nebenläufigkeit

Der Pipe-Operator |> leitet den Wert auf der linken Seite als erstes Argument an die Funktion auf der rechten Seite weiter. Er macht Transformationsketten ohne verschachtelte Klammern lesbar.

wert |> Funktion()            // entspricht: Funktion(wert)
wert |> Funktion(?, arg)      // entspricht: Funktion(wert, arg)
wert |> Funktion(arg, ?)      // entspricht: Funktion(arg, wert)

Der Platzhalter ? benennt die Stelle, an die der gepipte Wert eingesetzt wird. Bei einer Funktion ohne weitere Argumente kann die Klammer leer bleiben.

import std.math;
import std.io;

fn Clamp(val: f64, lo: f64, hi: f64): f64 {
    if (val < lo) { return lo; }
    if (val > hi) { return hi; }
    return val;
}

fn main(): int64 {
    // Ohne Pipe — schwer zu lesen bei tiefer Schachtelung
    var r1: f64 := RoundF64(Clamp(AbsF64(-3.7), 0.0, 3.0));

    // Mit Pipe — Datenfluss von links nach rechts
    var r2: f64 := -3.7 |> AbsF64() |> Clamp(?, 0.0, 3.0) |> RoundF64();

    PrintF64(r1);   // 3.7 → Abs → 3.7 → Clamp → 3.0 → Round → 3.0
    PrintLn("");
    PrintF64(r2);   // identisch
    PrintLn("");

    return 0;
}

fn Double(x: int64): int64  { return x * 2; }
fn Negate(x: int64): int64  { return -x; }
fn IsEven(x: int64): bool   { return x % 2 == 0; }

fn main(): int64 {
    var v: int64 := 5 |> Double() |> Negate();   // -10

    if (10 |> IsEven()) {
        PrintLn("gerade");
    }

    return 0;
}

// Exportierte Hilfsfunktion
pub fn Clamp(val: int64, lo: int64, hi: int64): int64 {
    if (val < lo) { return lo; }
    if (val > hi) { return hi; }
    return val;
}

// Einfache Funktionen inlinet der Codegen selbst; ein Attribut dafuer gibt es nicht
fn Abs(x: int64): int64 {
    if (x < 0) { return -x; }
    return x;
}

// Externe C-Funktion — extern fn mit link-Klausel, kein @extern-Attribut
extern fn strlen(s: pchar): int64 link "libc.so.6";

→ Alle Attribute: Attribute & Pragmas · FFI: C-Interoperabilität

Das folgende Beispiel kombiniert Tupel-Rückgabe, Funktionstypen und Higher-Order Functions in einem realistischen Muster:

import std.io;
import std.math;

// Funktionstypen
type Validator = fn(value: f64): bool;
type Transform = fn(value: f64): f64;

// Gibt (transformierterWert, erfolgreich) zurück
fn Process(value: f64,
           validate: Validator,
           transform: Transform): (f64, bool) {
    if (validate(value) == false) { return (0.0, false); }
    return (transform(value), true);
}

// Konkrete Implementierungen
fn IsPositive(v: f64): bool { return fGt(v, 0.0); }
fn Normalize(v: f64): f64   { return fDiv(v, 100.0); }

fn main(): int64 {
    var inputs: [4]f64 := [42.0, -5.0, 150.0, 0.0];
    var i: int64 := 0;

    while (i < 4) limit(4) {
        var out, ok := Process(inputs[i], IsPositive, Normalize);
        if (ok) {
            Print("OK: "); PrintF64(out); Print("\n");
        } else {
            Print("UNGUELTIG: "); PrintF64(inputs[i]); Print("\n");
        }
        i := i + 1;
    }
    return 0;
}

Ausgabe:

OK: 0.420000
UNGUELTIG: -5.000000
OK: 1.500000
UNGUELTIG: 0.000000

Letzte Aktualisierung: 2026-09-05 (#1264, nachgemessen mit lyxc 1.2.2B) — Kasten präzisiert: importierte Funktionen werden geprüft, Builtins nicht.

Vorherige letzte Aktualisierung: 2026-08-30 — Aufrufkonvention für fn-Zeiger ergänzt (#1274, Bruch gegenüber 0.9.x).

Vorherige Aktualisierung: 2026-08-09

Codebeispiele geprüft: gegen lyxc 1.2.5C übersetzt (Prüflauf 2026-09-08 über die gesamte Doku: 574 Vollprogramme, 0 echte Fehler; zusätzlich 5159 Aufrufe gegen die pub fn-Signaturen in aurum/std gehalten, 0 Abweichungen).