v3.1.0Tutorial

Type-Inference & Code-Ordering

Erfahre, wie VelinScript 3.1.0 komplexe Typen automatisch ableitet und Code basierend auf Abhängigkeiten sortiert.

Compiler Pipeline Flow

Code Source

AutoFix

Parser

Desugar

CodeOrdering

TypeInference

Build Orchestration

Codegen

1. Type::Any Member-Access

Das System unterstützt automatische Type-Inference für any Typen basierend auf Member-Namen. Das System erkennt den Typ automatisch, wenn du auf bekannte Member zugreifst.

Erwarteter Typ	Erkannte Member	Inferred Return
string	length, size, len	number
string	startsWith, endsWith, contains	boolean
list	map, filter, collect	list<any>
map	get, find	optional<any>

fn processData(data: any) {
    // Automatische Type-Inference
    if (data.startsWith("http://")) {
        // data.startsWith() → Boolean (automatisch inferiert)
        return data.toUpperCase(); // → String
    }
    
    if (data.length > 0) {
        // data.length → Number
        return data.trim(); // → String
    }
    
    // Unbekannte Member geben Any zurück (kein Fehler)
    return data.unknownMethod(); // → Any
}

Strings

length, startsWith, toUpperCase, trim

Lists

size, push, map, filter, find

Maps

get, set, has, keys, values

2. Result-Type Inference

Verbesserte Auflösung verschachtelter Result-Types und korrekte Type-Propagation.

fn fetchUser(): Result<Result<User, string>, string> {
    return Result.ok(Result.ok(User { name: "John" }));
}

fn main() {
    let result = fetchUser(); 
    // Automatische Auflösung zu Result<User, string>
    
    if (result.isOk()) {
        let user = result.unwrap(); // → User (korrekt inferiert)
    }
}

3. Desugared Code Type Inference

Das System verfeinert automatisch die Typen von transformierten Variablen wie __try_result oder __await_result_*.

fn fetchData(): Result<string, string> {
    try {
        return "success";
    } catch (e: string) {
        return Result.err("error");
    }
}

fn main() {
    // __try_result wird nach dem initialen Pass zu Result<string, string> verfeinert
    let result = __try_result;
    
    if (result.isOk()) {
        let data = result.unwrap(); // → string
    }
}

4. Automatic Code Ordering

Funktionen, Typen und Blöcke werden automatisch basierend auf ihren Abhängigkeiten sortiert.

Abhängigkeitsbasierte Sortierung

// User wird automatisch VOR createUser platziert
fn createUser(name: string): User {
    return User { name, email: "{name}@example.com" };
}

struct User {
    name: string;
    email: string;
}

Sortierreihenfolge:

Use Statements
TypeAliases & Enums
Structs & Traits
Impls & Functions
TopLevelCode

5. Build Orchestration

Der BuildOrchestrator analysiert use Statements, um die optimale Kompilierungsreihenfolge zwischen mehreren Dateien zu bestimmen.

Multi-File Dependency Analysis

Dateien werden in einem gerichteten azyklischen Graphen (DAG) organisiert. Zirkuläre Abhängigkeiten werden sofort gemeldet.

Zusammenfassung

Type-Inference

Any Member-Access
Result-Type Resolution
Desugared Type Refinement

Ordering

Automatic Function Ordering
Multi-File Orchestration
Circular Dependency Detection

String Interpolation Auth & Rollen