Rcal – Dimension-sicherer Kommandozeilen-Taschenrechner

1. Einleitung und Motivation

Rcal entstand aus dem Bedarf nach einem schnellen, zuverlässigen Tool für wissenschaftliche und technische Berechnungen direkt im Terminal. Normale Software-Taschenrechner verarbeiten ausschließlich nackte Zahlen, was bei komplexen physikalischen Formeln schnell zu unbemerkten Einheitenfehlern führt. Rcal kombiniert die Einfachheit eines CLI-Tools mit der Sicherheit echter Dimensionsanalyse und ermöglicht zudem die Automatisierung durch Skripte.

2. Problemstellung und Ziele

Problem: Klassische CLI-Rechner ignorieren physikalische Einheiten, was zu fehlerhaften Ergebnissen führen kann (z.B. die unbemerkte Addition von Metern und Sekunden). Zudem lassen sich komplexe Formeln oft nur schwer abspeichern und wiederverwenden.

Ziele:

Dimensionssicherheit: Striktes Verhindern von unmöglichen Berechnungen (z. B. 5m + 10s) durch ein integriertes SI-Einheitensystem.
Wiederverwendbarkeit: Definition eigener Variablen und Funktionen (z. B. f(x, y) = x^2 + y^2) sowie Ausführung von .rcal-Skripten.
Hervorragende UX: Syntax-Highlighting, Tab-Autovervollständigung für Konstanten/Einheiten und ortsbezogene Fehlerberichterstattung.
Performance & Sicherheit: Entwicklung einer schnellen und speichersicheren Anwendung in Rust.

3. Systemarchitektur und Design

Architekturüberblick: Rcal implementiert einen vollständigen, maßgeschneiderten Interpreter. Die Architektur trennt die Eingabeverarbeitung sauber von der mathematischen Auswertung.

Komponenten der Architektur:

Frontend (CLI): Nutzt das rustyline-Crate für interaktive Eingaben, Command-History, Syntax-Highlighting und Tab-Completion.
Lexer & Parser: Ein eigens geschriebener Lexer tokenisiert die Eingaben, woraufhin ein Recursive-Descent-Parser einen abstrakten Syntaxbaum (AST) generiert.
Evaluator: Führt den AST aus und verwaltet dabei den Zustand (Variablen, Funktionen). Hier findet die Dimensionsprüfung statt, bei der 8 Basisdimensionen (Länge, Masse, Zeit etc.) als Arrays verrechnet und validiert werden.

Architektur-Diagramm:

graph TD
    subgraph "Frontend (CLI)"
        UI[Rustyline Shell] -- Input --> Lexer[Lexer / Tokenizer]
    end

    subgraph "Interpreter Core"
        Lexer -- Tokens --> Parser[Parser]
        Parser -- Abstract Syntax Tree --> Evaluator[Evaluator]
        Evaluator -- Read / Write --> State[(Variables & Functions)]
        Evaluator -- Validation --> UnitSys[Unit System & Dimensions]
    end
    
    Evaluator -- Result / Error --> UI

4. Implementierungshighlights

Dimensionsanalyse-Engine: Das Einheitensystem trackt physikalische Grunddimensionen (wie Länge, Masse, Zeit) über ein Array aus Ganzzahlen ([i8; 8]). Multiplikationen (5N * 2m) erzeugen automatisch korrekt abgeleitete Einheiten (Joule), während inkompatible Additionen mit einer genauen Fehlermeldung sicher blockiert werden.

Custom Parser für natürliche Eingaben: Der Parser unterstützt natürliche mathematische Ausdrücke, einschließlich impliziter Multiplikation (z. B. 2pi oder 10m / 2s) und Programmierer-Werkzeuge wie bitweise Operationen und Basis-Konvertierungen (in hex, in bin).

Präzises Error-Handling: Tritt ein Syntax- oder Mathematikfehler auf (z.B. Division durch null oder Dimensionskonflikt), visualisiert Rcal den genauen Ort des Fehlers im Terminal oder gibt die fehlerhafte Zeilennummer im Skript-Modus aus.

5. Ergebnisse und Ausblick

Aktueller Stand: Rcal ist als interaktive Shell und Skript-Runner voll funktionsfähig. Es bietet fortgeschrittene Mathematik (Trigonometrie, Logarithmen), Aggregatfunktionen und ein Set an Naturkonstanten. Über GitHub Actions werden vollautomatisiert Binaries für Windows, macOS und Linux gebaut und als Releases bereitgestellt.

Nächste Schritte:

Erweiterte Datentypen: Unterstützung für Vektoren und Matrizen für komplexere physikalische Berechnungen.
Standard-Bibliothek: Ausbau der integrierten physikalischen und chemischen Konstanten.
Library-Export: Bereitstellung der Rcal-Engine als eigenständiges Rust-Crate für andere Projekte.

6. Persönliches Wachstum und Lessons Learned

Compiler- und Interpreterbau: Ich habe tiefe Einblicke in die Konstruktion von Lexern, abstrakten Syntaxbäumen (AST) und zustandsbasierten Evaluatoren gewonnen. Einen Parser komplett "from scratch" zu schreiben, war eine der lehrreichsten Erfahrungen.

Rust & Speichersicherheit: Das Projekt hat mein Verständnis für die strikten Typisierungs- und Ownership-Konzepte von Rust stark gefestigt, insbesondere bei der Gestaltung der Interpreter-Architektur.