v3.0.185+ Module450+ Funktionen

Standardbibliothek

Die Velisch 3.0.1 Standardbibliothek bietet eine performante Basis für moderne Web- und KI-Anwendungen mit über 85 Modulen und 450+ Funktionen.

Bibliotheks-Generator

Eigene Module für die Standardbibliothek erstellen

Module nach Kategorie

string

split, join, replace, trim, slugify, capitalize...

math

clamp, lerp, round_to, random_range, min, max...

date

add_days, add_hours, format_relative, is_weekend...

datetime

now, format, parse, add, subtract, diff...

json

parse, stringify, get, set, merge, validate...

regex

match, find, find_all, replace, split...

collections

filter, map, reduce, find, sort, chunk...

iterators

group_by, sorted, multizip, chunks, unique...

fs / fileio

read_file, write_file, file_exists, read_json...

crypto

sha256, md5, random_string, uuid, hash_password...

path

join, base, ext, is_absolute, normalize...

os / env

get_env, set_env, args, hostname, cpu_count...

runtime

version, gc, memory_usage, platform...

reflect

type_of, fields, methods, call_dynamic...

errors

Error, Result, panic, catch_unwind...

serialization

serialize, deserialize, to_yaml, from_yaml...

result

ok, err, unwrap, unwrap_or, map, map_err...

std:http - Web Server & Routing

Dekorator-basierter Ansatz für API-Entwicklung mit automatischem Routing.

import { http, Context } from "std:http";

@GET("/api/v1/status")
fn getStatus(ctx: Context) {
    return ctx.json({ status: "ok", version: "2.7" });
}

@Middleware
fn logger(ctx: Context, next: Fn) {
    println("Request: {ctx.method} {ctx.path}");
    next();
}

@POST("/api/v1/users")
@Use(logger)
fn createUser(ctx: Context) {
    let body = ctx.body<CreateUserInput>();
    return ctx.status(201).json(db.save(body));
}

std:json - High-Speed Serialisierung

Optimiert durch Rusts serde für maximale Performance.

import { json } from "std:json";

struct Config {
    host: string,
    port: number,
    debug: boolean,
    tags: List<string>,
}

// Deserialisierung
let config = json.parse<Config>(rawJson);
println(config.host);  // → "localhost"

// Serialisierung
let encoded = json.stringify(config);

// Path-basierter Zugriff
let port = json.get(rawJson, "server.port");

// Merge
let merged = json.merge(defaults, overrides);

std:ai - KI & LLM Integration

Native Abstraktionen für LLM-Provider, Embeddings und ML-Modelle.

import { ai } from "std:ai";

// LLM-Completion
let model = ai.loadModel("gpt-4o");
let response = await model.complete({
    prompt: "Erkläre Rust in einem Satz",
    temperature: 0.7,
    maxTokens: 100,
});

// Embeddings für Vektor-Suche
let embedding = ai.embeddings("Suchanfrage", "text-embedding-3-small");

// Sentiment-Analyse
let sentiment = ai.analyze("Tolles Produkt!", "sentiment");
println(sentiment.label);  // → "positive"

// Chat mit History
let chat = ai.createChat("gpt-4o");
chat.addMessage("user", "Hallo!");
let reply = await chat.send();

std:auth - Authentifizierung

JWT, OAuth2 und Multi-Factor Authentication aus der Box.

import { jwt, AuthService, MFAService } from "std:auth";

// JWT Token erstellen
let token = jwt.sign({
    sub: user.id,
    role: user.role,
    exp: now() + "7d",
}, env.JWT_SECRET);

// AuthService für komplexere Flows
let auth = AuthService.new(env.JWT_SECRET);
let claims = auth.verify_token(token);

// MFA-Verifizierung
let mfa = MFAService.new();
let valid = mfa.verify_totp(userToken, userSecret);

// OAuth2
let oauth = OAuth2Provider.new(clientId, clientSecret, redirectUri);
let authUrl = oauth.get_authorization_url(state);

std:validation - Input-Validierung

Fluent Validator API für sichere Eingabevalidierung.

import { Validator } from "std:validation";

fn validateUser(input: CreateUserInput): Result<(), List<ValidationError>> {
    return Validator.new()
        .required("name", input.name)
        .min_length("name", input.name, 3)
        .max_length("name", input.name, 50)
        .email("email", input.email)
        .min("age", input.age, 18)
        .pattern("username", input.username, "^[a-z0-9_]+$", "Nur Kleinbuchstaben")
        .validate();
}

Feature-Flags

Einige Module erfordern spezielle Feature-Flags in velisch.toml:

axum

Axum-Integration

actix

Actix-Integration

sea-orm

SeaORM-Integration

oauth2

OAuth2-Support

privacy

DSGVO-Tools

vault

Secrets-Management

tls

TLS/SSL

ml

ML Features

velisch.tomltoml

[package]
name = "my-project"
version = "0.1.0"

[features]
default = ["axum", "sea-orm"]
oauth2 = true
ml = true

Decorators & Annotations

@VelischAutoDoc

Generiert automatische Dokumentation aus /// Doc-Comments mit Typ-Signaturen und KI-Context.

@VelischPipeline

Analysiert Datenabhängigkeiten und optimiert sequentielle Aufrufe zu parallelen Gruppen mit tokio::join!.

Syntax Authentifizierung