v3.1.0SprachgrundlagenStable

VelinScript Sprachgrundlagen

Die Brücke zwischen High-Level Skripting und System-Performance.

Willkommen zum umfassenden Handbuch für die VelinScript-Sprachgrundlagen. VelinScript ist eine moderne, statisch typisierte Programmiersprache, die entwickelt wurde, um die Lücke zwischen High-Level-Skriptsprachen und performanten Systemprogrammiersprachen zu schließen. Sie kombiniert eine ausdrucksstarke Syntax mit strikter Typsicherheit und einer mächtigen Standardbibliothek.

1. Einführung und Typsystem

VelinScript ist statisch typisiert. Durch moderne Typinferenz fühlt es sich jedoch oft wie eine dynamische Sprache an.

Basistypen

string UTF-8 Zeichenketten

number 64-Bit Fließkomma (f64)

boolean Wahrheitswerte (true/false)

void Abwesenheit eines Wertes

null Explizites "Kein Wert"

any Typ-Escape (sparsam nutzen)

Generics

fn identity<T>(value: T): T {
    return value;
}

let s = identity<string>("Test");

2. Variablen und Konstanten

// Typinferenz: Compiler erkennt 'number'
let x = 10;

// Explizite Typangabe
let y: string = "Explizit";

// Spätere Zuweisung (Initialisierungspflicht)
let z: boolean;
z = true;

3. Kollektionen im Detail

Listen unterstützen Auto-Parallelisierung bei großen Datenmengen (> 1000 Elemente).

let numbers = [1, 2, 3, 4, 5];

// Funktionale Operationen
let sum = numbers
    .filter(|n| n % 2 == 0)
    .map(|n| n * n)
    .reduce(|acc, val| acc + val, 0);

4. Funktionen, Closures & Lambdas

Standard & Lambdas

// Klassisch
fn add(a: number, b: number): number {
    return a + b;
}

// Lambda Syntax
let doubler = |n| n * 2;

// Kurzform mit implizitem Return
fn multiply(a: number, b: number) => a * b;

Closures

fn createAdder(base: number): fn(number) -> number {
    return |n| n + base; // fängt 'base'
}

let addFive = createAdder(5);
log.info(addFive(2)); // 7

5. Kontrollfluss und Pattern Matching

Modern Loops & If

Klammern sind seit v3.0 optional.

if x > 5 {
    log.info("Groß");
}

for i in 0..10 {
    log.info(i);
}

Pattern Matching (Match)

match status {
    200 => log.info("Alles OK"),
    400..499 => log.error("Client Fehler"),
    500 if server.isDown() => log.error("Server Down"),
    _   => log.warn("Unbekannt")
}

6. Fehlerbehandlung

fn findUser(id: string): User? { ... } // Optional

fn parse(input: string): Result<number, string> { ... }

// Verwendung
let val = parse("42").unwrapOr(0);

7. Objektorientierte Konzepte

Structs

struct User {
    id: string,
    @Validate(min: 0)
    age: number
}

let u = User { id: "1", age: 30 };

Enums (ADTs)

enum Payment {
    Cash,
    PayPal(string)
}

let p = Payment.PayPal("e@mail.com");

8. Best Practices

Immutability bevorzugen

Nutzen Sie funktionale Methoden wie map/filter statt Schleifen mit Mutationen.

Typsicherheit

Vermeiden Sie 'any'. Nutzen Sie Generics und Result-Typen für robuste Fehlerbehandlung.

Kleine Funktionen

Fokussierte Funktionen sind leichter zu testen und zu parallelisieren.

Schnellstart Specification