diff --git a/DEFINITION.md b/DEFINITION.md index 14b0b74..ddec401 100644 --- a/DEFINITION.md +++ b/DEFINITION.md @@ -1,5 +1,7 @@ # **HypnoScript** – Eine esoterische, TypeScript-inspirierte Sprache mit hypnotischem Flair +> _"You are feeling very sleepy... Your code is getting deeper... and deeper..."_ + --- ## **Inhaltsverzeichnis** @@ -7,12 +9,15 @@ - [**HypnoScript** – Eine esoterische, TypeScript-inspirierte Sprache mit hypnotischem Flair](#hypnoscript--eine-esoterische-typescript-inspirierte-sprache-mit-hypnotischem-flair) - [**Inhaltsverzeichnis**](#inhaltsverzeichnis) - [**1. Einleitung**](#1-einleitung) + - [1.1 Philosophie](#11-philosophie) + - [1.2 Design-Prinzipien](#12-design-prinzipien) - [**2. Grundaufbau**](#2-grundaufbau) - [2.1 Lexikalische Struktur](#21-lexikalische-struktur) - [2.2 Schlüsselwörter](#22-schlüsselwörter) - [2.3 Operatoren und Sonderzeichen](#23-operatoren-und-sonderzeichen) - [2.4 Bezeichner (Identifier)](#24-bezeichner-identifier) - [2.5 Literale](#25-literale) + - [2.6 Typ-System und Annotationen](#26-typ-system-und-annotationen) - [**3. Syntax**](#3-syntax) - [3.1 Programmstruktur](#31-programmstruktur) - [3.2 Deklarationen](#32-deklarationen) @@ -26,25 +31,79 @@ - [3.5.1 Objektorientierung: `session`](#351-objektorientierung-session) - [3.5.2 Warte-Mechanismus: `drift(ms)`](#352-warte-mechanismus-driftms) - [3.5.3 Hypnotische Operator-Synonyme](#353-hypnotische-operator-synonyme) + - [Tafel der klassischen Suggestionen](#tafel-der-klassischen-suggestionen) + - [Moderne Traum-Semantik](#moderne-traum-semantik) - [3.5.4 Benutzerdefinierte Strukturen/Typen: `tranceify`](#354-benutzerdefinierte-strukturentypen-tranceify) - - [3.5.5 Weitere Gimmicks (optional)](#355-weitere-gimmicks-optional) + - [3.5.5 Muster-Entraining: `entrain`](#355-muster-entraining-entrain) + - [3.5.6 Asynchrone Trance: `mesmerize` \& `await`](#356-asynchrone-trance-mesmerize--await) + - [3.5.7 Module \& gemeinsame Trancen](#357-module--gemeinsame-trancen) + - [3.5.8 Trigger: Event-Hooks \& Callback-Mechanismen](#358-trigger-event-hooks--callback-mechanismen) + - [Beispiel 1: Cleanup-Trigger](#beispiel-1-cleanup-trigger) + - [Beispiel 2: Event-Handler für Wiederholungen](#beispiel-2-event-handler-für-wiederholungen) + - [Beispiel 3: Parametrisierte Trigger](#beispiel-3-parametrisierte-trigger) + - [Beispiel 4: Trigger in Sessions](#beispiel-4-trigger-in-sessions) + - [3.5.9 Hypnotische Werkzeuge (Best-of)](#359-hypnotische-werkzeuge-best-of) - [**4. Grammatik (EBNF)**](#4-grammatik-ebnf) - [**5. Semantik**](#5-semantik) - [5.1 Variablen und Scope](#51-variablen-und-scope) - [5.2 Ein- / Ausgabe](#52-ein---ausgabe) - [5.3 Turing-Vollständigkeit](#53-turing-vollständigkeit) - - [**6. Beispielprogramme**](#6-beispielprogramme) - - [6.1 Einfaches „Hello Trance!“](#61-einfaches-hello-trance) - - [6.2 Summierung mit Input](#62-summierung-mit-input) - - [6.3 Verwendung erweiterter Konzepte](#63-verwendung-erweiterter-konzepte) - - [6.3.1 `session`, `drift`, Operator-Synonyme](#631-session-drift-operator-synonyme) + - [5.4 Fehlerbehandlung: Albtraum-Management](#54-fehlerbehandlung-albtraum-management) + - [5.5 Parallelität und Trance-Synchronisation](#55-parallelität-und-trance-synchronisation) + - [**6. Standardbibliothek**](#6-standardbibliothek) + - [6.1 Tranceify-Bibliothek (Kernfunktionen)](#61-tranceify-bibliothek-kernfunktionen) + - [6.2 Hypno-Math (Mathematische Funktionen)](#62-hypno-math-mathematische-funktionen) + - [6.3 StringSpell (String-Manipulation)](#63-stringspell-string-manipulation) + - [6.4 MemoryPalace (Datenstrukturen)](#64-memorypalace-datenstrukturen) + - [6.5 TimeWarp (Zeit- und Datumsfunktionen)](#65-timewarp-zeit--und-datumsfunktionen) + - [6.6 DeepMind (Erweiterte Kontrollstrukturen)](#66-deepmind-erweiterte-kontrollstrukturen) + - [6.7 SensoryInput (Ein-/Ausgabe-Funktionen)](#67-sensoryinput-ein-ausgabe-funktionen) + - [6.8 AuraAsync (Asynchronität \& Tasks)](#68-auraasync-asynchronität--tasks) + - [6.9 DreamWeaver Patterns (Pattern Matching)](#69-dreamweaver-patterns-pattern-matching) + - [6.10 Stagecraft Visions (UI \& Präsentation)](#610-stagecraft-visions-ui--präsentation) + - [6.11 HypnoNet (Netzwerk \& APIs)](#611-hypnonet-netzwerk--apis) + - [6.12 RealityAnchor (Persistenz \& Storage)](#612-realityanchor-persistenz--storage) + - [6.13 LucidDiagnostics (Debugging \& Telemetrie)](#613-luciddiagnostics-debugging--telemetrie) + - [**7. Beispielprogramme**](#7-beispielprogramme) + - [7.1 Einfaches „Hello Trance!“](#71-einfaches-hello-trance) + - [7.2 Summierung mit Input](#72-summierung-mit-input) + - [7.3 Verwendung erweiterter Konzepte](#73-verwendung-erweiterter-konzepte) + - [7.3.1 `session`, `drift`, Operator-Synonyme](#731-session-drift-operator-synonyme) --- ## **1. Einleitung** -**HypnoScript** ist eine minimalistische, esoterische Sprache, die sich an die Syntax von TypeScript/JavaScript anlehnt und dabei alle möglichen Klischees rund um Hypnose, Trance und hypnotische Induktion verwendet. -Trotz des humorvollen Charakters ist sie auf Turing-Vollständigkeit ausgelegt und unterstützt Variablen, Schleifen, bedingte Anweisungen, Funktionen, Objektorientierung (als _Session-Konzept_) und diverse Sprach-Gimmicks im hypnotischen Stil. +**HypnoScript** ist eine moderne, esoterische Programmiersprache, die sich an die Syntax von TypeScript/JavaScript anlehnt und dabei konsequent Klischees und Metaphern aus der Welt der Hypnose verwendet. Die Sprache vereint humorvolle Themenwahl mit ernsthafter Funktionalität und bietet ein vollständiges, Turing-vollständiges Sprachsystem. + +### 1.1 Philosophie + +HypnoScript folgt dem Paradigma der **"Hypnotischen Programmierung"**, bei der: + +- **Code als Suggestion** betrachtet wird – Programme sind Sequenzen von Suggestionen an den Computer +- **Variablen in Trance versetzt** werden – Werte werden induziert, implantiert oder eingebettet +- **Kontrollfluss als Trance-Tiefe** metaphorisiert wird – tiefere Verschachtelung = tiefere Trance +- **Funktionen als hypnotische Suggestions** wirken – sie beeinflussen den Zustand des Programms +- **Fehler als "Erwachen aus der Trance"** behandelt werden – unerwartete Zustände durchbrechen den Flow + +### 1.2 Design-Prinzipien + +1. **Konsistenz**: Alle Sprachelemente folgen der hypnotischen Metapher +2. **Lesbarkeit**: Trotz esoterischer Begriffe bleibt die Struktur vertraut +3. **Modernität**: Unterstützung für Pattern Matching, Async/Await, Type Safety +4. **Vollständigkeit**: Umfangreiche Standardbibliothek für praktische Anwendungen +5. **Spaß**: Die Sprache soll zum Experimentieren einladen und unterhalten + +**Kerneigenschaften:** + +- Turing-vollständig +- Statisches Typsystem mit Typ-Inferenz +- Objektorientierung mit Session-Konzept +- Funktionale Programmierung (First-Class Functions, Closures, Lambda) +- Pattern Matching +- Async/Await für asynchrone Operationen +- Umfassende Standardbibliothek +- Module-System für Code-Organisation --- @@ -52,61 +111,96 @@ Trotz des humorvollen Charakters ist sie auf Turing-Vollständigkeit ausgelegt u ### 2.1 Lexikalische Struktur -- **Groß- und Kleinschreibung**: In dieser Definition gehen wir davon aus, dass Schlüsselwörter case-sensitive sind und stets in **Kleinschreibung** geschrieben werden. -- **Kommentare**: - - Einzeilig: `// Kommentar` +- **Groß- und Kleinschreibung**: In dieser Definition gehen wir davon aus, dass Schlüsselwörter case-sensitive sind und stets in **Kleinschreibung** geschrieben werden. +- **Kommentare**: + - Einzeilig: `// Kommentar` - Mehrzeilig: `/* ... */` ### 2.2 Schlüsselwörter ```plaintext Focus, Relax, -if, else, -while, loop, -snap, sink, -suggestion, awaken, call, -entrance, -deepFocus, -induce, -observe, -trance, -from, external, -number, string, boolean, -true, false, +entrance, finale, +if, else, when, otherwise, +while, loop, pendulum, +snap, sink, sinkTo, +suggestion, mesmerize, awaken, await, surrenderTo, call, +entrain, +induce, implant, embed, freeze, sharedTrance, +observe, whisper, command, murmur, +mindLink, from, external, session, constructor, expose, conceal, dominant, -drift, -youAreFeelingVerySleepy, lookAtTheWatch, fallUnderMySpell, -tranceify, -mindLink, sharedTrance, -imperative +tranceify, anchor, trigger, oscillate, +drift, suspend, pauseReality, accelerateTime, decelerateTime, +deepFocus, deeperStill, +trance, subconscious, lucid, +number, string, boolean, +true, false, +youAreFeelingVerySleepy, lookAtTheWatch, fallUnderMySpell, +youCannotResist, yourEyesAreGettingHeavy, goingDeeper, +underMyControl, resistanceIsFutile, lucidFallback, dreamReach ``` -_(Die zusätzlichen hypnotischen Begriffe siehe Kapitel „Erweiterte Konzepte“.)_ +> Hinweis: Zusätzliche hypnotische Begriffe findest du in Kapitel „Erweiterte Konzepte“. ### 2.3 Operatoren und Sonderzeichen -- **Zuweisung**: `=` -- **Arithmetisch**: `+`, `-`, `*`, `/`, `%` -- **Vergleich**: `==`, `!=`, `>`, `>=`, `<`, `<=` (ergänzt durch hypnotische Synonyme, siehe [3.5.3](#hypnotische-operator-synonyme)) -- **Logisch**: `&&`, `||`, `!` +- **Zuweisung**: `=` +- **Arithmetisch**: `+`, `-`, `*`, `/`, `%` +- **Vergleich**: `==`, `!=`, `>`, `>=`, `<`, `<=` (ergänzt durch hypnotische Synonyme, siehe [3.5.3](#353-hypnotische-operator-synonyme)) +- **Logisch**: `&&`, `||`, `!` +- **Nullish/Optional**: `??`, `?.` (alias `lucidFallback`, `dreamReach`) - **Trennzeichen/Klammern**: `;`, `,`, `(`, `)`, `{`, `}`, `[` , `]` ### 2.4 Bezeichner (Identifier) -- **Syntax**: - - Beginnend mit einem Buchstaben `a-z`/`A-Z` oder `_` - - Gefolgt von beliebigen Buchstaben, Ziffern `0-9` oder `_` +- **Syntax**: + - Beginnend mit einem Buchstaben `a-z`/`A-Z` oder `_` + - Gefolgt von beliebigen Buchstaben, Ziffern `0-9` oder `_` -Beispiele: `counter`, `myVar2`, `_hiddenField`. +Beispiele: `counter`, `myVar2`, `_hiddenField`. Schlüsselwörter dürfen nicht als Bezeichner verwendet werden. ### 2.5 Literale -- **Numerisch**: `42`, `3.14` -- **String**: `"Hello Trance!"` (Escapes optional, z. B. `\"`) -- **Boolean**: `true`, `false` -- _(Optionaler Fantasietyp `trance` hat keine separaten Literale, kann aber als Typannotation dienen.)_ +- **Numerisch**: `42`, `3.14` +- **String**: `"Hello Trance!"` (Escapes optional, z. B. `\"`) +- **Boolean**: `true`, `false` + +> Hinweis: Der Fantasietyp `trance` besitzt keine Literale, eignet sich aber als Typannotation. + +### 2.6 Typ-System und Annotationen + +HypnoScript residiert in einer statisch getypten, aber äußerst suggestiven Traumwelt. Jede Variable kann – muss aber nicht – einen sichtbaren Typ tragen. Fehlt die Annotation, induziert der Interpreter den Typ via Trance-Intuition. + +- **Basistypen**: `number`, `string`, `boolean`, `trance` (für bewusstseinserweiterte Payloads). +- **Modifier**: `lucid` markiert Werte als optional/entrückt (`lucid string` ≙ `string | null | undefined`). +- **Kombinationen**: Union (`typeA | typeB`) und Intersection (`typeA & typeB`) werden unterstützt – passend zu verschmelzenden Trancezuständen. +- **Generics**: Funktionen, Sessions und `tranceify`-Typen können Typparameter verwenden (`suggestion anchor(value: T): T`). +- **Optionale Felder**: Das Suffix `?` auf einem Feld/einer Signatur kennzeichnet „sanft mögliche“ Werte. +- **Nullish-Handling**: Der Operator `lucidFallback` (Alias für `??`) und `dreamReach` (Alias für `?.`) helfen, schlafwandelnde Werte sicher zu berühren. + +```plaintext +induce guestCount: number = 42; +induce mantra: lucid string; // optionaler Wert +induce guestRegistry = { entries: [] }; + +tranceify HypnoGuest { + name: string; + memory: TMemory; + isInTrance: boolean; + suggestionLevel?: number; +} + +suggestion summonEcho(value: T | trance, fallback: T): T { + awaken value lucidFallback fallback; +} + +observe guestRegistry dreamReach entries lucidFallback []; +``` + +> Hinweis: `lucidFallback` (`??`) und `dreamReach` (`?.`) sind syntaktischer Zucker für Nullish-Coalescing und Optional-Chaining – passend ins hypnotische Bühnenbild übersetzt. --- @@ -124,10 +218,10 @@ Focus { } Relax ``` -Optionale Besonderheit: +Optionale Besonderheit: -- **`entrance { ... }`** kann als „Startblock“ dienen. - - Wenn vorhanden, wird der Code im `entrance`-Block zuerst ausgeführt. +- **`entrance { ... }`** kann als „Startblock“ dienen. + - Wenn vorhanden, wird der Code im `entrance`-Block zuerst ausgeführt. - Ist kein `entrance`-Block definiert, wird das Programm z. B. von oben nach unten abgearbeitet oder folgt anderen Implementierungsdetails. ### 3.2 Deklarationen @@ -139,7 +233,7 @@ induce x: number = 5; induce y: string = "Hallo"; ``` -- Mit oder ohne Initialisierung. +- Mit oder ohne Initialisierung. - **Input**: `induce name: string from external;` – kann (fiktiv) einen Wert von außen einlesen. #### 3.2.2 Funktionen – `suggestion` @@ -150,7 +244,7 @@ suggestion add(a: number, b: number): number { } ``` -- **Aufruf**: +- **Aufruf**: ```plaintext add(2, 3); @@ -158,9 +252,10 @@ suggestion add(a: number, b: number): number { call add(2, 3); ``` -- **Rückgabe**: `awaken ;` (analog zu `return`). +- **Rückgabe**: `awaken ;` (analog zu `return`). +- **Modifiers**: `mesmerize suggestion` erzeugt asynchrone Funktionen, `imperative suggestion` kennzeichnet Prozeduren, `dominant suggestion` statische/bibliothekarische Hooks. -_(Für Funktionen ohne Rückgabewert kann man wahlweise `imperative suggestion` verwenden, siehe [3.5](#erweiterte-konzepte).)_ +> Hinweis: Für Funktionen ohne Rückgabewert kann man wahlweise `imperative suggestion` verwenden (siehe [3.5](#35-erweiterte-konzepte)). ### 3.3 Kontrollstrukturen @@ -174,7 +269,7 @@ if (x > 0) { } ``` -- **`deepFocus`** als optionaler Ersatz für `{ }`-Blöcke: +- **`deepFocus`** als optionaler Ersatz für `{ }`-Blöcke: ```plaintext if (counter > 5) deepFocus { @@ -203,12 +298,12 @@ loop (induce i: number = 0; i < 5; i = i + 1) { } ``` -- **`snap;`**: bricht Schleife ab (analog `break`). +- **`snap;`**: bricht Schleife ab (analog `break`). - **`sink;`**: springt zum nächsten Durchlauf (analog `continue`). ### 3.4 Blöcke -- Geschweifte Klammern `{ ... }` oder optional `deepFocus { ... }` als Block. +- Geschweifte Klammern `{ ... }` oder optional `deepFocus { ... }` als Block. - Mehrere Anweisungen können in einem Block stehen. ### 3.5 **Erweiterte Konzepte** @@ -240,10 +335,10 @@ session Person { p.greet(); ``` -- `expose`: Feld/Methoden sind öffentlich (zugreifbar von außen). -- `conceal`: Feld/Methoden sind privat (nur innerhalb der Session). -- **`constructor`**: Spezialmethode, die bei Instanzierung aufgerufen wird. -- **`dominant suggestion`**: (optional) für statische Methoden (z. B. `MathWizard.power(a,b)`). +- `expose`: Feld/Methoden sind öffentlich (zugreifbar von außen). +- `conceal`: Feld/Methoden sind privat (nur innerhalb der Session). +- **`constructor`**: Spezialmethode, die bei Instanzierung aufgerufen wird. +- **`dominant suggestion`**: (optional) für statische Methoden (z. B. `MathWizard.power(a,b)`). #### 3.5.2 Warte-Mechanismus: `drift(ms)` @@ -255,22 +350,58 @@ drift(3000); observe "...Nach 3 Sekunden geht's weiter."; ``` -_(Implementierung abhängig von Interpreter/Runtime.)_ +> Hinweis: Die konkrete Warte-Strategie hängt von Interpreter oder Runtime ab. #### 3.5.3 Hypnotische Operator-Synonyme -Neben den üblichen `==`, `>`, `<` usw. können folgende Synonyme verwendet werden: +Wo andere Sprachen nüchtern vergleichen, flüstert HypnoScript beschwörende Formeln. Jede Vergleichs- und Logikoperation besitzt ein theatrales Alias, das exakt dieselbe Semantik behält – nur viel mehr Show liefert. -- **`youAreFeelingVerySleepy`** statt `==` +##### Tafel der klassischen Suggestionen - ```plaintext - if (x youAreFeelingVerySleepy y) { ... } - ``` +| Standard-Operator | Hypnotisches Synonym | Bedeutung | +| ----------------- | ------------------------- | ------------------- | -------------------- | -------------- | +| `==` | `youAreFeelingVerySleepy` | Gleichheit | +| `!=` | `youCannotResist` | Ungleichheit | +| `>` | `lookAtTheWatch` | Größer als | +| `<` | `fallUnderMySpell` | Kleiner als | +| `>=` | `yourEyesAreGettingHeavy` | Größer oder gleich | +| `<=` | `goingDeeper` | Kleiner oder gleich | +| `&&` | `underMyControl` | Logisches UND | +| ` | | ` | `resistanceIsFutile` | Logisches ODER | + +##### Moderne Traum-Semantik + +| Konstruktion | Hypnotisches Synonym | Wirkung | +| ------------ | -------------------- | ------------------------------ | +| `??` | `lucidFallback` | Nullish-Coalescing | +| `?.` | `dreamReach` | Optional-Chaining auf Objekten | +| `?.[` | `dreamReach[` | Optionaler Indexzugriff | +| `?.(` | `dreamReach(` | Optionaler Funktionsaufruf | -- **`lookAtTheWatch`** statt `>` -- **`fallUnderMySpell`** statt `<` +Die Synonyme können frei mit den Standardoperatoren gemischt werden. Für konsistente Hypnose empfiehlt es sich, pro Datei einen Stil zu wählen. -_(Beliebige weitere Wortspiele für `!=`, `>=`, `<=` etc. sind denkbar.)_ +```plaintext +induce age: number = 22; +induce license: boolean = true; +if (age lookAtTheWatch 18 underMyControl license youAreFeelingVerySleepy true) { + observe "Du darfst fahren!"; +} + +induce guest = { profile: { alias: "Hypna" } }; +induce dossier = guest dreamReach profile lucidFallback {}; +observe dossier; + +induce x: number = 7; +induce y: number = 42; +if (x goingDeeper 100 resistanceIsFutile y yourEyesAreGettingHeavy 50) { + command "Bedingung erfüllt – trance tiefer!"; +} + +induce password: string = "secret"; +if (password youCannotResist "trance123") { + observe "Falsches Passwort!"; +} +``` #### 3.5.4 Benutzerdefinierte Strukturen/Typen: `tranceify` @@ -291,23 +422,287 @@ induce r = HypnoRecord { observe r.name; ``` -- Weist Felder per `{ feldname: wert, ... }` zu. +- Weist Felder per `{ feldname: wert, ... }` zu. - Intern kann dies wie eine _struct_ oder ein _Record_ behandelt werden. -#### 3.5.5 Weitere Gimmicks (optional) +#### 3.5.5 Muster-Entraining: `entrain` -- **`imperative suggestion`**: Eine Funktion ohne Rückgabewert (Prozedur). -- **`mindLink "myLibrary.hyp";`**: Zum Import weiterer Module/Dateien. -- **`sharedTrance`**: Globale Variablen-Definition. -- **Sprünge** (Goto-ähnlich): +`entrain` ist HypnoScripts Pattern-Matching und wirkt wie ein sanftes Einschwingen auf unterschiedliche Bewusstseinslagen. Der Ausdruck wird einmal evaluiert, anschließend werden die `when`-Klauseln der Reihe nach geprüft. Die erste passende Suggestion gewinnt; `otherwise` dient als Fallback. - ```plaintext - myLabel: - observe "Label erreicht!"; - if (x < 10) sinkTo myLabel; - ``` +- Literale (`when 0`, `when "Spirale"`). +- Typ-Patterns mit optionaler Bindung (`when value: number`). +- Destrukturierung von `tranceify`-Records und Arrays (`when HypnoGuest { name, isInTrance: true }`). +- Guards mit `if` für zusätzliche Bedingungen. +- Spread-Operator `...rest` innerhalb von Array-Pattern. + +```plaintext +induce input: any = HypnoGuest<{ tranceDepth: number }> { + name: "Luna", + memory: { tranceDepth: 7 }, + isInTrance: true, + suggestionLevel: 5, +}; + +entrain input { + when 0 => command "Nullpunkt erreicht."; + when value: number if value lookAtTheWatch 0 => command "Positive Schwingung!"; + when HypnoGuest { name, isInTrance: true } => observe name + " ist tief in Trance."; + when [first, ...rest] => observe "Liste startet mit " + first; + otherwise => observe "Unbekannter Bewusstseinszustand"; +} +``` + +Jede `when`-Klausel kann `awaken` verwenden, um einen Wert zurückzugeben. `entrain` selbst ist also ein Ausdruck und lässt sich direkt einer Variable zuweisen. + +#### 3.5.6 Asynchrone Trance: `mesmerize` & `await` + +Für Operationen, die im Hintergrund schweben, markiert `mesmerize` eine Funktion als hypnotisch-asynchron. Der Rückgabewert entspricht einem Promise; `await` (alias `surrenderTo`) löst die Suggestion auf. + +```plaintext +mesmerize suggestion lullaby(): number { + drift(1200); + awaken 42; +} + +Focus { + induce answer: number = await lullaby(); + observe "Antwort aus dem Traum: " + answer; + + induce secondAnswer: number = surrenderTo lullaby(); + observe "Alias funktioniert ebenso."; +} Relax +``` + +`mesmerize` kann mit `session` kombiniert werden, um hypnotische Services zu definieren. Innerhalb von `mesmerize`-Funktionen stehen `parallelTrance` und `scheduleAwakening` aus der Standardbibliothek zur Verfügung. + +#### 3.5.7 Module & gemeinsame Trancen + +Das Modul-System bildet die Bühne, auf der mehrere Skripte gemeinsam schwingen. + +```plaintext +mindLink "./rituals/spiral.hyp"; +mindLink { chant as deepChant } from "./choir.hyp"; + +sharedTrance freeze stageLighting: string = "violett"; +sharedTrance induce visitorCount: number = 0; + +imperative suggestion incrementVisitors() { + visitorCount = visitorCount + 1; + deepChant(); +} +``` + +- `mindLink` lädt Module; benannte Importe funktionieren wie in modernen JS-Ökosystemen. +- `sharedTrance` deklariert modulweite Zustände (ggf. mit `freeze`). +- `manifest` (optional) kann verwendet werden, um Assets zu exportieren (Implementierungsdetail des Toolings). + +#### 3.5.8 Trigger: Event-Hooks & Callback-Mechanismen + +`trigger` ist ein mächtiges Werkzeug zum Definieren von Top-Level Event-Hooks, Callbacks und verzögerten Aktionen. Ein Trigger bindet eine Funktions-Expression an einen Bezeichner auf Programm- oder Modul-Ebene und kann später explizit aufgerufen oder als Reaktion auf bestimmte Ereignisse ausgelöst werden. + +**Syntax:** + +```plaintext +// Nur auf Top-Level (außerhalb von Funktionen/Sessions/Blöcken) +trigger triggerName = suggestion(parameterList) { + // Trigger-Code +}; +``` + +**Eigenschaften:** + +- **Top-Level Only**: Triggers können **nur** auf Programm- oder Modul-Ebene deklariert werden (nicht innerhalb von Funktionen, Sessions oder Blöcken) +- **Deklarativ**: Triggers werden wie Variablen deklariert, binden aber Funktionslogik +- **First-Class**: Können als Parameter übergeben, in Datenstrukturen gespeichert und dynamisch aufgerufen werden +- **Event-Orientiert**: Ideal für Event-Handler, Callbacks, Cleanup-Aktionen und verzögerte Ausführungen +- **Kombination mit Bibliotheken**: Perfekt mit `repeatAction`, `delayedSuggestion`, `awakenAfter` aus DeepMind/AuraAsync + +**Verwendungsmuster:** + +1. **Cleanup-Trigger**: Aufräumaktionen nach Programmende (oft in `finale`-Blöcken) +2. **Event-Handler**: Reaktion auf Benutzer-Interaktionen oder Systemereignisse +3. **Callback-Funktionen**: Als Parameter für höhere Funktionen (DeepMind, MemoryPalace) +4. **State-Management**: Zustandsänderungs-Handler in komplexen Sessions + +### Beispiel 1: Cleanup-Trigger + +```plaintext +Focus { + induce resourceHandle: number = 42; + + trigger onCleanup = suggestion() { + command "Ressourcen werden freigegeben..."; + resourceHandle = 0; + observe "Cleanup abgeschlossen."; + }; + + // Programm-Logik... + observe "Hauptprogramm läuft..."; + + finale { + onCleanup(); // Expliziter Aufruf des Triggers + } +} Relax +``` + +### Beispiel 2: Event-Handler für Wiederholungen + +```plaintext +Focus { + induce counter: number = 0; + + trigger onTick = suggestion() { + counter = counter + 1; + observe "Tick " + counter; + }; + + // Verwende Trigger mit DeepMind + repeatAction(5, onTick); + + observe "Finale Zählung: " + counter; +} Relax +``` + +### Beispiel 3: Parametrisierte Trigger + +```plaintext +Focus { + trigger onError = suggestion(errorCode: number, message: string) { + command "⚠️ FEHLER " + errorCode + ": " + message; + drift(1000); + }; + + induce x: number = 10; + if (x lookAtTheWatch 100) { + onError(404, "Wert zu groß!"); + } +} Relax +``` + +### Beispiel 4: Trigger in Sessions + +```plaintext +// Trigger als Top-Level-Deklaration außerhalb der Session +trigger onSecondElapsed = suggestion(timer: HypnoTimer) { + timer.elapsedSeconds = timer.elapsedSeconds + 1; + observe "Verstrichene Zeit: " + timer.elapsedSeconds + "s"; +}; + +session HypnoTimer { + expose elapsedSeconds: number; + + suggestion constructor() { + this.elapsedSeconds = 0; + } + + suggestion start() { + // Verwende externen Trigger mit Partial Application + induce boundTick = suggestion() { + onSecondElapsed(this); + }; + repeatAction(10, boundTick); + } +} + +Focus { + induce timer = HypnoTimer(); + timer.start(); +} Relax +``` + +**Unterschied zu normalen Funktionen:** + +| Aspekt | `suggestion` | `trigger` | +| ------------------ | --------------------------------------- | ------------------------------------------- | +| Deklaration | `suggestion name(params): type { ... }` | `trigger name = suggestion(params) { ... }` | +| Gültigkeitsbereich | Block-Level (lokal/global) | Nur Top-Level (Programm/Modul-Scope) | +| Semantik | Wiederverwendbare Funktion | Event-Handler/Callback | +| Verwendung | Allgemeine Logik | Ereignisgesteuert | +| Konvention | Algorithmen, Berechnungen | Reaktionen, Cleanup, Events | + +**Wichtige Einschränkungen:** + +- `trigger` kann **nur auf Top-Level** deklariert werden (nicht innerhalb von Sessions, Funktionen oder Blöcken) +- Für Callback-Felder in Sessions verwende anonyme `suggestion`-Expressions direkt: `this.callback = suggestion() { ... };` +- Triggers können als Werte zugewiesen und als Parameter übergeben werden (First-Class) - _(Extremes Feature – kann, muss aber nicht verwendet werden.)_ +**Alternative: Anonyme Suggestion-Expressions für lokale Callbacks** + +Wenn du Callbacks innerhalb von Sessions oder Funktionen benötigst, verwende direkt anonyme `suggestion`-Expressions: + +```plaintext +session MySession { + conceal localCallback: suggestion; + + suggestion constructor() { + // Anonyme suggestion-Expression (kein trigger!) + this.localCallback = suggestion(value: number) { + observe "Callback aufgerufen mit: " + value; + }; + } +} +``` + +**Best Practices:** + +- Verwende `trigger` für Top-Level Event-Handler und globale Callbacks +- Benenne Triggers mit Präfix `on` für Klarheit (`onAwaken`, `onError`, `onComplete`) +- Für lokale Callbacks innerhalb von Sessions/Funktionen: nutze anonyme `suggestion() { ... }` +- Kombiniere mit `finale`-Blöcken für garantierte Ausführung +- Nutze Triggers in Kombination mit DeepMind-Funktionen für elegante Kontrollflüsse + +> Hinweis: Trigger sind syntaktischer Zucker für Funktions-Expressions mit event-orientierter Semantik. Intern werden sie als First-Class Functions behandelt. + +#### 3.5.9 Hypnotische Werkzeuge (Best-of) + +Eine Auswahl weiterer Sprachjuwelen, die den Hypnose-Charakter abrunden: + +- `imperative suggestion`: Prozedur ohne Rückgabewert. +- `anchor`: Zustand sichern (Snapshot einer Variablen). +- `oscillate`, `pendulum`: Toggler und bidirektionale Schleifen. +- `suspend`: Pausiert ohne festes Ende, bis ein Trigger aufweckt. +- `freeze`: Macht Variablen unveränderlich. +- `whisper`, `command`, `murmur`: Ausgabestufen vom Flüstern bis zur Autorität. +- `implant`/`embed`: Alternativen zu `induce` für tiefere Speicheroperationen. +- `subconscious`: Zugriff auf verborgene Speicherbereiche. +- `sinkTo label;`: Goto-artiger Sprung für dramatische Effekte – möglichst sparsam einsetzen. +- `finale { ... }`: Aufräum- und Abschlussblock nach dem Hauptprogramm. + +> Siehe auch [3.5.8 Trigger](#358-trigger-event-hooks--callback-mechanismen) für vollständige Event-Hook-Dokumentation. + +```plaintext +sharedTrance freeze mantraText: string = "Atme ein, atme aus"; + +Focus { + anchor baselineDepth = 3; + induce isDeepening: boolean = false; + + oscillate isDeepening; + if (isDeepening) { + observe "Trance wird vertieft auf Level: " + baselineDepth; + } + + pendulum (induce i: number = 0; i fallUnderMySpell 3) { + whisper mantraText + " (" + i + ")"; + drift(300); + } + + trigger onAwaken = suggestion() { + command "Du bist wieder ganz da."; + }; + + // Nostalgischer Sprung, bitte nur im Ausnahmefall: + myLabel: + baselineDepth = baselineDepth - 1; + if (baselineDepth fallUnderMySpell 1) sinkTo myLabel; + + finale { + onAwaken(); + } +} Relax +``` + +> Hinweis: Viele dieser Features sind Zuckerguss. Für produktive Hypnose gilt – dosiert einsetzen, damit niemand aus der Trance fällt. --- @@ -316,142 +711,199 @@ observe r.name; Nachfolgend eine beispielhafte EBNF-Skizze, die die Kernsyntax (ohne alle Operator-Synonyme) abbildet. Die Synonyme (`youAreFeelingVerySleepy`, etc.) könnten in der Praxis direkt auf die Standardoperatoren gemappt werden. ```ebnf -Program ::= "Focus" Block "Relax" ; - -Block ::= { Statement } ; - -Statement ::= VarDeclarationStatement - | ExpressionStatement - | IfStatement - | WhileStatement - | LoopStatement - | BreakStatement - | ContinueStatement - | FunctionDeclaration - | ReturnStatement - | ObserveStatement - | EntranceBlock - | SessionDeclaration - | TranceifyDeclaration - | BlockStatement - ; - -BlockStatement ::= ("deepFocus" |) "{" { Statement } "}" - ; - -EntranceBlock ::= "entrance" BlockStatement ; +Program ::= "Focus" Block [ FinaleBlock ] "Relax" ; + +Block ::= { Statement } ; + +Statement ::= VarDeclarationStatement + | SharedTranceDeclaration + | FreezeStatement + | MindLinkStatement + | EntrainStatement + | IfStatement + | WhileStatement + | LoopStatement + | PendulumStatement + | BreakStatement + | ContinueStatement + | FunctionDeclaration + | TriggerDeclaration + | ReturnStatement + | ObserveStatement + | WhisperStatement + | CommandStatement + | DriftStatement + | AnchorStatement + | OscillateStatement + | SessionDeclaration + | TranceifyDeclaration + | EntranceBlock + | FinaleBlock + | LabelStatement + | SinkToStatement + | BlockStatement + | ExpressionStatement ; + +BlockStatement ::= [ "deepFocus" | "deeperStill" ] "{" { Statement } "}" ; + +EntranceBlock ::= "entrance" BlockStatement ; +FinaleBlock ::= "finale" BlockStatement ; VarDeclarationStatement - ::= "induce" Identifier [ ":" Type ] [ "=" Expression ] ";" - | "induce" Identifier [ ":" Type ] "from" "external" ";" ; + ::= ("induce" | "implant" | "embed") Identifier [ ":" Type ] [ "=" Expression ] ";" + | ("induce" | "implant") Identifier [ ":" Type ] "from" "external" ";" ; + +SharedTranceDeclaration + ::= "sharedTrance" ("freeze" | "induce" | "implant" | "embed") + Identifier [ ":" Type ] [ "=" Expression ] ";" ; + +FreezeStatement ::= "freeze" Identifier ":" Type "=" Expression ";" ; + +MindLinkStatement + ::= "mindLink" StringLiteral [ "as" Identifier ] ";" + | "mindLink" "{" ImportList "}" "from" StringLiteral ";" ; -ObserveStatement - ::= "observe" Expression ";" ; +ImportList ::= ImportSpecifier { "," ImportSpecifier } ; +ImportSpecifier ::= Identifier [ "as" Identifier ] ; -IfStatement ::= "if" "(" Expression ")" BlockStatement - [ "else" BlockStatement ] ; +ObserveStatement ::= "observe" Expression ";" ; +WhisperStatement ::= "whisper" Expression ";" ; +CommandStatement ::= "command" Expression ";" ; -WhileStatement ::= "while" "(" Expression ")" BlockStatement ; +DriftStatement ::= ("drift" | "pauseReality") "(" Expression ")" ";" + | "suspend" ";" ; -LoopStatement ::= "loop" "(" [ VarDeclarationStatementNoSemicolon ] - ";" Expression ";" Expression ")" - BlockStatement ; +AnchorStatement ::= "anchor" Identifier "=" Expression ";" ; +OscillateStatement ::= "oscillate" Identifier ";" ; -BreakStatement ::= "snap" ";" ; -ContinueStatement - ::= "sink" ";" ; +LabelStatement ::= Identifier ":" ; +SinkToStatement ::= "sinkTo" Identifier ";" ; + +PendulumStatement + ::= "pendulum" "(" [ VarDeclarationStatementNoSemicolon ] + ";" Expression ";" Expression ")" + BlockStatement ; + +IfStatement ::= "if" "(" Expression ")" BlockStatement [ "else" BlockStatement ] ; +WhileStatement ::= "while" "(" Expression ")" BlockStatement ; +LoopStatement ::= "loop" "(" [ VarDeclarationStatementNoSemicolon ] + ";" Expression ";" Expression ")" BlockStatement ; + +BreakStatement ::= "snap" ";" ; +ContinueStatement::= "sink" ";" ; FunctionDeclaration - ::= ( "suggestion" | "imperative suggestion" | "dominant suggestion" ) - Identifier "(" [ ParameterList ] ")" [ ":" Type ] - BlockStatement ; + ::= FunctionModifier Identifier "(" [ ParameterList ] ")" [ ":" Type ] + BlockStatement ; + +FunctionModifier ::= [ "mesmerize" ] ( "suggestion" + | "imperative suggestion" + | "dominant suggestion" ) ; + +TriggerDeclaration + ::= "trigger" Identifier "=" FunctionExpression ";" ; -ParameterList ::= Parameter { "," Parameter } ; -Parameter ::= Identifier [ ":" Type ] ; +FunctionExpression + ::= [ "mesmerize" ] "suggestion" "(" [ ParameterList ] ")" + BlockStatement ; -ReturnStatement ::= "awaken" [ Expression ] ";" ; +ParameterList ::= Parameter { "," Parameter } ; +Parameter ::= Identifier [ ":" Type ] ; + +ReturnStatement ::= "awaken" [ Expression ] ";" ; ExpressionStatement - ::= Expression ";" ; + ::= Expression ";" ; -Expression ::= AssignmentExpression ; +Expression ::= AssignmentExpression ; AssignmentExpression - ::= LogicalOrExpression [ "=" AssignmentExpression ] ; + ::= LogicalOrExpression [ "=" AssignmentExpression ] ; LogicalOrExpression - ::= LogicalAndExpression - { "||" LogicalAndExpression } ; + ::= LogicalAndExpression { ( "||" | "resistanceIsFutile" ) LogicalAndExpression } ; LogicalAndExpression - ::= EqualityExpression - { "&&" EqualityExpression } ; + ::= EqualityExpression { ( "&&" | "underMyControl" ) EqualityExpression } ; EqualityExpression - ::= RelationalExpression - { ( "==" | "!=" | "youAreFeelingVerySleepy" ) - RelationalExpression } ; // Bsp. für Synonym + ::= RelationalExpression { EqualityOperator RelationalExpression } ; + +EqualityOperator ::= "==" | "!=" | "youAreFeelingVerySleepy" | "youCannotResist" ; RelationalExpression - ::= AdditiveExpression - { ( ">" | ">=" | "<" | "<=" - | "lookAtTheWatch" | "fallUnderMySpell" ) - AdditiveExpression } ; + ::= AdditiveExpression { RelationalOperator AdditiveExpression } ; + +RelationalOperator + ::= ">" | ">=" | "<" | "<=" + | "lookAtTheWatch" | "yourEyesAreGettingHeavy" + | "fallUnderMySpell" | "goingDeeper" ; AdditiveExpression - ::= MultiplicativeExpression - { ( "+" | "-" ) MultiplicativeExpression } ; + ::= MultiplicativeExpression { ( "+" | "-" ) MultiplicativeExpression } ; MultiplicativeExpression - ::= UnaryExpression - { ( "*" | "/" | "%" ) UnaryExpression } ; + ::= UnaryExpression { ( "*" | "/" | "%" ) UnaryExpression } ; -UnaryExpression ::= [ ("+" | "-" | "!") ] PrimaryExpression ; +UnaryExpression ::= ( "await" | "surrenderTo" ) UnaryExpression + | [ ("+" | "-" | "!") ] PrimaryExpression ; PrimaryExpression - ::= Identifier - | Literal - | "(" Expression ")" - | FunctionCall - ; + ::= Identifier + | Literal + | "(" Expression ")" + | FunctionCall + | FunctionExpression + | EntrainExpression ; + +FunctionCall ::= [ "call" ] Identifier "(" [ ArgumentList ] ")" ; + +EntrainExpression + ::= "entrain" Expression "{" EntrainClause { EntrainClause } [ EntrainDefault ] "}" ; -FunctionCall ::= [ "call" ] Identifier "(" [ ArgumentList ] ")" ; +EntrainStatement ::= EntrainExpression ";" ; -ArgumentList ::= Expression { "," Expression } ; +EntrainClause ::= "when" Pattern [ "if" Expression ] "=>" BlockStatement ; +EntrainDefault ::= "otherwise" "=>" BlockStatement ; + +Pattern ::= Literal + | Identifier + | Identifier ":" Type + | Identifier "{" RecordPatternEntry { "," RecordPatternEntry } "}" + | "[" [ Pattern { "," Pattern } [ "," "..." Identifier ] ] "]" ; + +RecordPatternEntry ::= Identifier [ ":" Pattern ] [ "=" Expression ] ; + +ArgumentList ::= Expression { "," Expression } ; SessionDeclaration - ::= "session" Identifier "{" { SessionMember } "}" ; + ::= "session" Identifier "{" { SessionMember } "}" ; -SessionMember ::= ( "expose" | "conceal" )? - ( VarDeclarationStatementNoSemicolon - | FunctionDeclaration - | ConstructorDeclaration ) ; +SessionMember ::= ( "expose" | "conceal" )? + ( VarDeclarationStatementNoSemicolon + | FunctionDeclaration + | ConstructorDeclaration ) ; ConstructorDeclaration - ::= "suggestion" "constructor" "(" [ ParameterList ] ")" - BlockStatement ; + ::= "suggestion" "constructor" "(" [ ParameterList ] ")" BlockStatement ; TranceifyDeclaration - ::= "tranceify" Identifier "{" { VarDefinition } "}" ; + ::= "tranceify" Identifier "{" { VarDefinition } "}" ; -VarDefinition ::= Identifier ":" Type ";" ; +VarDefinition ::= Identifier ":" Type ";" ; VarDeclarationStatementNoSemicolon - ::= "induce" Identifier [ ":" Type ] [ "=" Expression ] - | "induce" Identifier [ ":" Type ] "from" "external" ; + ::= ("induce" | "implant" | "embed") Identifier [ ":" Type ] [ "=" Expression ] + | ("induce" | "implant") Identifier [ ":" Type ] "from" "external" ; -Literal ::= NumericLiteral - | StringLiteral - | BooleanLiteral ; +Literal ::= NumericLiteral | StringLiteral | BooleanLiteral ; +NumericLiteral ::= Digit { Digit } [ "." Digit { Digit } ] ; +StringLiteral ::= '"' { } '"' ; +BooleanLiteral ::= "true" | "false" ; -NumericLiteral ::= Digit { Digit } [ "." Digit { Digit } ] ; -StringLiteral ::= '"' { } '"' ; -BooleanLiteral ::= "true" | "false" ; +Type ::= "number" | "string" | "boolean" | "trance" | Identifier ; -Type ::= "number" | "string" | "boolean" | "trance" - | Identifier ; // Für benutzerdefinierte Typen, struct-Namen etc. - -Digit ::= [0-9] ; +Digit ::= [0-9] ; ``` --- @@ -460,29 +912,592 @@ Digit ::= [0-9] ; ### 5.1 Variablen und Scope -- **`induce varName: type = expr;`**: Deklariert eine lokale Variable im aktuellen Block. -- **Gültigkeit**: Variablen sind innerhalb des Blockes und seiner Unterblöcke sichtbar (lexikalischer Scope). -- **Zuweisung**: `varName = expr;` ändert den Wert einer bereits deklarierten Variable. +- **`induce varName: type = expr;`**: Deklariert eine lokale Variable im aktuellen Block. +- **Gültigkeit**: Variablen sind innerhalb des Blockes und seiner Unterblöcke sichtbar (lexikalischer Scope). +- **Zuweisung**: `varName = expr;` ändert den Wert einer bereits deklarierten Variable. - **Eingabe**: `from external` simuliert Benutzer-/Dateiinput (Implementation abhängig). ### 5.2 Ein- / Ausgabe -- **`observe expr;`**: Gibt den Wert von `expr` (z. B. String, Zahl, boolean) an das „Trance-Log“ aus (Konsole, UI, etc.). -- **`drift(ms);`**: Unterbricht / pausiert den Programmfluss (themenbedingt „Verzögerung in Trance“). +- **`observe expr;`**: Gibt den Wert von `expr` (z. B. String, Zahl, boolean) an das „Trance-Log“ aus (Konsole, UI, etc.). +- **`drift(ms);`**: Unterbricht / pausiert den Programmfluss (themenbedingt „Verzögerung in Trance“). ### 5.3 Turing-Vollständigkeit -- **Schleifen (while, loop)** bzw. **Rekursion** ermöglichen beliebig lange bzw. wiederholende Prozesse. -- **Bedingte Verzweigungen (if/else)** erlauben dynamische Pfadwahl. -- **Variablen** speichern veränderbare Werte. +- **Schleifen (while, loop)** bzw. **Rekursion** ermöglichen beliebig lange bzw. wiederholende Prozesse. +- **Bedingte Verzweigungen (if/else)** erlauben dynamische Pfadwahl. +- **Variablen** speichern veränderbare Werte. Diese Faktoren reichen aus, um Turing-Vollständigkeit zu gewährleisten. +### 5.4 Fehlerbehandlung: Albtraum-Management + +HypnoScript kennt Ausnahmen als **Nightmares**. Sobald ein Nightmare ausgelöst wird, bricht die aktuelle Suggestion ab, bis eine passende Recovery-Suggestion eingreift. + +- `tryOrAwaken(action, recovery)`: Führt `action` aus und ruft bei Nightmare `recovery` auf. +- `ensureAwakening(action, cleanup)`: Stellt sicher, dass `cleanup` ausgeführt wird (ähnlich `finally`). +- `lucidFallback`: Ausdrucksebene für Nullish- bzw. Fehler-Ersatzwerte. +- `dreamReach`: Optional-Chaining schützt vor `subconscious`-Nullzuständen. + +```plaintext +tryOrAwaken( + suggestion() { + surrenderTo fetchSuggestion("https://hypno.api/session"); + }, + suggestion(nightmare: Nightmare) { + murmur "Albtraum: " + nightmare.message; + observe "Wir atmen tief durch und versuchen es erneut."; + } +); + +ensureAwakening( + suggestion() { openVault(); }, + suggestion() { closeVault(); } +); +``` + +### 5.5 Parallelität und Trance-Synchronisation + +Asynchrone Suggestionen (`mesmerize`, `await`) und die Bibliotheken AuraAsync sowie DeepMind ermöglichen nebeneinander laufende Hypnosen. + +- `parallelTrance` startet mehrere Suggestionen gleichzeitig und wartet auf Abschluss. +- `sequentialTrance` erzwingt Reihenfolge, nützlich beim Aktualisieren von `sharedTrance`-Zuständen. +- `auraToken` / `cancelSuggestion` erlauben Abbrüche. +- `sharedTrance`-Variablen sind per Definition threadsicher; für kritische Abschnitte kann `anchor` + `oscillate` zur Koordination genutzt werden. + +```plaintext +Focus { + sharedTrance induce stage: string = "warmup"; + + parallelTrance([ + suggestion() { stage = "intro"; surrenderTo lullaby(); }, + suggestion() { observe "Publikum zählt rückwärts"; } + ]); + + sequentialTrance([ + suggestion() { stage = "climax"; }, + suggestion() { command "3...2...1..."; } + ]); +} Relax +``` + --- -## **6. Beispielprogramme** +## **6. Standardbibliothek** + +Die HypnoScript-Standardbibliothek bietet eine umfassende Sammlung von hypnotisch benannten Funktionen und Modulen, die häufige Programmieraufgaben vereinfachen. Alle Bibliotheksfunktionen folgen dem hypnotischen Thema und verwenden suggestive Bezeichnungen. + +### 6.1 Tranceify-Bibliothek (Kernfunktionen) + +Die Kernbibliothek stellt grundlegende Funktionen für Typkonvertierung und Basisdatenmanipulation bereit. + +```plaintext +// Typkonvertierungen +suggestion toNumber(value: string): number +suggestion toString(value: number): string +suggestion toBoolean(value: any): boolean + +// Typ-Prüfungen +suggestion isNumber(value: any): boolean +suggestion isString(value: any): boolean +suggestion isBoolean(value: any): boolean +suggestion isTranced(value: any): boolean // Prüft, ob Wert in "Trance" ist (null/undefined) + +// Grundlegende Utilities +suggestion clone(obj: any): any // Tiefe Kopie eines Objekts +suggestion absorb(target: any, source: any): any // Merge von Objekten (hypnotisches "merge") +suggestion reflect(value: any): string // Gibt Typ-Information zurück +``` + +**Beispiel:** + +```plaintext +Focus { + induce numStr: string = "42"; + induce num: number = toNumber(numStr); + observe "Konvertiert: " + num; + + if (isNumber(num)) { + observe "Es ist eine Zahl!"; + } +} Relax +``` + +### 6.2 Hypno-Math (Mathematische Funktionen) + +Das Hypno-Math-Modul bietet erweiterte mathematische Funktionen mit hypnotischen Namen. + +```plaintext +// Grundlegende Operationen +suggestion power(base: number, exponent: number): number // Potenzierung +suggestion squareRoot(n: number): number // Quadratwurzel (visualisiere die Spirale...) +suggestion absoluteDepth(n: number): number // Absolutwert (Tiefe ist immer positiv) + +// Rundungsfunktionen +suggestion ceiling(n: number): number // Aufrunden (aufsteigen aus der Trance) +suggestion floor(n: number): number // Abrunden (sinken in die Trance) +suggestion roundToNearest(n: number): number // Runden zur nächsten Ganzzahl + +// Trigonometrische Funktionen (Pendel-Bewegungen) +suggestion pendulumSin(angle: number): number // sin +suggestion pendulumCos(angle: number): number // cos +suggestion pendulumTan(angle: number): number // tan + +// Erweiterte Funktionen +suggestion spiralLog(n: number): number // Logarithmus (Spirale nach innen) +suggestion spiralExp(n: number): number // Exponentialfunktion (Spirale nach außen) +suggestion hypnoticPi(): number // π (3.14159...) +suggestion hypnoticE(): number // e (2.71828...) + +// Min/Max (Dominant/Submissive Auswahl) +suggestion selectDominant(a: number, b: number): number // max +suggestion selectSubmissive(a: number, b: number): number // min +suggestion clampBetween(value: number, min: number, max: number): number // Begrenzt Wert + +// Zufallsfunktionen (Unbewusste Entscheidungen) +suggestion unconsciousChoice(): number // Zufallszahl zwischen 0 und 1 +suggestion unconsciousInt(min: number, max: number): number // Zufallsganzzahl +suggestion unconsciousBool(): boolean // Zufälliger boolean +``` + +**Beispiel:** + +```plaintext +Focus { + induce radius: number = 5.0; + induce area: number = hypnoticPi() * power(radius, 2); + observe "Kreisfläche: " + area; -### 6.1 Einfaches „Hello Trance!“ + induce angle: number = 45.0; + induce sine: number = pendulumSin(angle); + observe "Sinus von " + angle + " Grad: " + sine; + + induce randomNum: number = unconsciousInt(1, 100); + observe "Zufällige Zahl: " + randomNum; +} Relax +``` + +### 6.3 StringSpell (String-Manipulation) + +StringSpell bietet mächtige String-Manipulationsfunktionen mit hypnotischen Metaphern. + +```plaintext +// Länge und Zugriff +suggestion measureDepth(str: string): number // Länge des Strings +suggestion extractEssence(str: string, index: number): string // Zeichen an Position +suggestion sliceMemory(str: string, start: number, end: number): string // Substring + +// Suchen und Ersetzen +suggestion findPattern(str: string, pattern: string): number // indexOf +suggestion containsPattern(str: string, pattern: string): boolean // includes +suggestion replaceMemory(str: string, old: string, new: string): string // replace +suggestion replaceAllMemories(str: string, old: string, new: string): string // replaceAll + +// Transformation +suggestion toUpper(str: string): string // In Großbuchstaben (LAUTER BEFEHL) +suggestion toLower(str: string): string // In Kleinbuchstaben (sanftes Flüstern) +suggestion trimEdges(str: string): string // Entfernt Whitespace an den Rändern +suggestion reverseTrance(str: string): string // Kehrt String um + +// Zerlegung und Zusammenfügung +suggestion fragmentMemory(str: string, delimiter: string): string[] // split +suggestion mergeThoughts(arr: string[], separator: string): string // join +suggestion repeatMantra(str: string, times: number): string // String wiederholen + +// Prüfungen +suggestion startsWithSuggestion(str: string, prefix: string): boolean +suggestion endsWithAwakening(str: string, suffix: string): boolean +suggestion matchesPattern(str: string, regex: string): boolean // Regex-Match +``` + +**Beispiel:** + +```plaintext +Focus { + induce message: string = " Willkommen in der Trance "; + induce cleaned: string = trimEdges(message); + observe cleaned; + + induce words: string[] = fragmentMemory(cleaned, " "); + observe "Anzahl Wörter: " + vaultSize(words); + + induce mantra: string = repeatMantra("Om ", 3); + observe mantra; // "Om Om Om " + + induce reversed: string = reverseTrance("Trance"); + observe reversed; // "ecnarT" +} Relax +``` + +### 6.4 MemoryPalace (Datenstrukturen) + +MemoryPalace bietet Funktionen für Arrays und erweiterte Datenstrukturen. + +```plaintext +// Array-Grundfunktionen +suggestion createVault(size: number): any[] // Erstellt Array mit Größe +suggestion storeMemory(arr: any[], value: any): number // push - gibt neue Länge zurück +suggestion retrieveLastMemory(arr: any[]): any // pop +suggestion peekAtMemory(arr: any[], index: number): any // Array-Zugriff +suggestion implantMemory(arr: any[], index: number, value: any) // Setze Wert an Index + +// Array-Manipulation +suggestion reverseMemories(arr: any[]): any[] // Kehrt Array um +suggestion sortMemories(arr: any[]): any[] // Sortiert Array +suggestion filterMemories(arr: any[], predicate: suggestion): any[] // filter +suggestion mapMemories(arr: any[], transformer: suggestion): any[] // map +suggestion reduceToEssence(arr: any[], reducer: suggestion, initial: any): any // reduce + +// Array-Suche +suggestion findMemory(arr: any[], value: any): number // indexOf +suggestion containsMemory(arr: any[], value: any): boolean // includes +suggestion countOccurrences(arr: any[], value: any): number // Zählt Vorkommen + +// Array-Info +suggestion vaultSize(arr: any[]): number // Länge +suggestion isEmptyVault(arr: any[]): boolean // Ist leer +suggestion firstMemory(arr: any[]): any // Erstes Element +suggestion lastMemory(arr: any[]): any // Letztes Element + +// Erweiterte Strukturen (Maps/Dictionaries) +session MemoryMap { + expose suggestion constructor() + expose suggestion store(key: string, value: any) + expose suggestion retrieve(key: string): any + expose suggestion forget(key: string) + expose suggestion hasKey(key: string): boolean + expose suggestion allKeys(): string[] + expose suggestion allValues(): any[] +} + +// Stack (LIFO) +session MindStack { + expose suggestion constructor() + expose suggestion push(value: any) + expose suggestion pop(): any + expose suggestion peek(): any + expose suggestion isEmpty(): boolean + expose suggestion size(): number +} + +// Queue (FIFO) +session ThoughtQueue { + expose suggestion constructor() + expose suggestion enqueue(value: any) + expose suggestion dequeue(): any + expose suggestion isEmpty(): boolean + expose suggestion size(): number +} +``` + +**Beispiel:** + +```plaintext +Focus { + // Array-Operationen + induce memories: number[] = [1, 2, 3, 4, 5]; + induce doubled = mapMemories(memories, suggestion(x: number): number { + awaken x * 2; + }); + observe doubled; // [2, 4, 6, 8, 10] + + // Stack verwenden + induce stack = MindStack(); + stack.push(10); + stack.push(20); + stack.push(30); + observe stack.pop(); // 30 + observe stack.peek(); // 20 + + // Map verwenden + induce map = MemoryMap(); + map.store("name", "Alice"); + map.store("age", 30); + observe map.retrieve("name"); // "Alice" +} Relax +``` + +### 6.5 TimeWarp (Zeit- und Datumsfunktionen) + +TimeWarp ermöglicht Zeit- und Datumsmanipulation mit hypnotischen Konzepten. + +```plaintext +// Aktuelle Zeit +suggestion nowInTrance(): number // Aktuelle Timestamp (Millisekunden seit Epoch) +suggestion currentMoment(): string // Aktuelles Datum/Zeit als String + +// Zeit-Manipulation +suggestion pauseReality(ms: number) // Entspricht drift(ms) - pausiert Ausführung +suggestion accelerateTime(factor: number) // Beschleunigt nachfolgende Operationen (konzeptionell) +suggestion decelerateTime(factor: number) // Verlangsamt nachfolgende Operationen + +// Datum-Parsing und Formatierung +suggestion parseTimeMoment(dateStr: string): number // String zu Timestamp +suggestion formatTimeMoment(timestamp: number, format: string): string // Timestamp zu formatiertem String + +// Datum-Arithmetik +suggestion addDays(timestamp: number, days: number): number +suggestion addHours(timestamp: number, hours: number): number +suggestion addMinutes(timestamp: number, minutes: number): number +suggestion addSeconds(timestamp: number, seconds: number): number +suggestion differenceInDays(ts1: number, ts2: number): number +suggestion differenceInHours(ts1: number, ts2: number): number +suggestion differenceInMinutes(ts1: number, ts2: number): number +suggestion differenceInSeconds(ts1: number, ts2: number): number + +// Datum-Komponenten +suggestion extractYear(timestamp: number): number +suggestion extractMonth(timestamp: number): number +suggestion extractDay(timestamp: number): number +suggestion extractHour(timestamp: number): number +suggestion extractMinute(timestamp: number): number +suggestion extractSecond(timestamp: number): number +``` + +**Beispiel:** + +```plaintext +Focus { + induce now: number = nowInTrance(); + observe "Aktueller Timestamp: " + now; + + induce tomorrow: number = addDays(now, 1); + induce formatted: string = formatTimeMoment(tomorrow, "YYYY-MM-DD"); + observe "Morgen: " + formatted; + + pauseReality(2000); // Warte 2 Sekunden + observe "2 Sekunden später..."; +} Relax +``` + +### 6.6 DeepMind (Erweiterte Kontrollstrukturen) + +DeepMind bietet erweiterte Kontrollfluss- und Funktionskompositionswerkzeuge. + +```plaintext +// Wiederholungen mit Callbacks +suggestion repeatAction(times: number, action: suggestion) +suggestion repeatUntil(condition: suggestion, action: suggestion) +suggestion repeatWhile(condition: suggestion, action: suggestion) + +// Verzögerte Ausführung +suggestion delayedSuggestion(action: suggestion, delayMs: number) +suggestion scheduleAwakening(action: suggestion, timestamp: number) + +// Funktionskomposition +suggestion compose(f: suggestion, g: suggestion): suggestion // f(g(x)) +suggestion pipe(f: suggestion, g: suggestion): suggestion // g(f(x)) +suggestion curry(f: suggestion, arg: any): suggestion // Partial application + +// Bedingte Ausführung +suggestion ifTranced(condition: boolean, thenAction: suggestion, elseAction: suggestion) +suggestion switchMindState(value: any, cases: MemoryMap, defaultCase: suggestion) + +// Fehlerbehandlung (Awakening from Nightmare) +suggestion tryOrAwaken(action: suggestion, recoveryAction: suggestion) +suggestion ensureAwakening(action: suggestion, cleanupAction: suggestion) // try-finally + +// Async/Concurrency (Parallele Trancen) +suggestion parallelTrance(actions: suggestion[]) // Führt mehrere Aktionen parallel aus +suggestion sequentialTrance(actions: suggestion[]) // Führt Aktionen nacheinander aus +``` + +**Beispiel:** + +```plaintext +Focus { + // Wiederhole eine Aktion 5 mal + repeatAction(5, suggestion() { + observe "In Trance..."; + }); + + // Verzögerte Ausführung + observe "Vor der Verzögerung"; + delayedSuggestion(suggestion() { + observe "Nach 3 Sekunden"; + }, 3000); + + // Bedingte Ausführung + induce x: number = 10; + ifTranced(x lookAtTheWatch 5, + suggestion() { observe "x ist größer als 5"; }, + suggestion() { observe "x ist nicht größer als 5"; } + ); +} Relax +``` + +### 6.7 SensoryInput (Ein-/Ausgabe-Funktionen) + +SensoryInput erweitert die Ein- und Ausgabemöglichkeiten von HypnoScript. + +```plaintext +// Ausgabe-Funktionen +suggestion observe(message: any) // Standard-Ausgabe mit Zeilenumbruch +suggestion whisper(message: any) // Ausgabe ohne Zeilenumbruch +suggestion command(message: any) // Fett/hervorgehobene Ausgabe +suggestion murmur(message: any) // Gedämpfte/Debug-Ausgabe + +// Formatierte Ausgabe +suggestion observeFormatted(template: string, ...args: any[]) // String-Interpolation +suggestion observeTable(data: any[][]) // Gibt Tabelle aus +suggestion observeJson(obj: any) // Gibt JSON-formatiert aus + +// Eingabe-Funktionen +suggestion requestInput(prompt: string): string // Fordert Benutzer-Eingabe an +suggestion requestNumber(prompt: string): number // Fordert Zahl an +suggestion requestConfirmation(prompt: string): boolean // Ja/Nein-Frage +suggestion requestChoice(prompt: string, options: string[]): number // Mehrfachauswahl + +// Datei-I/O (konzeptionell) +suggestion absorbFromScroll(filename: string): string // Liest Datei +suggestion manifestToScroll(filename: string, content: string) // Schreibt Datei +suggestion appendToScroll(filename: string, content: string) // Hängt an Datei an + +// Stream-Ausgabe (fortgeschritten) +suggestion observeStream(generator: suggestion) // Stream-basierte Ausgabe +suggestion collectThoughts(): string[] // Sammelt alle bisherigen Ausgaben +``` + +**Beispiel:** + +```plaintext +Focus { + // Verschiedene Ausgabearten + observe "Normale Ausgabe"; + whisper "Ohne Zeilenumbruch... "; + whisper "zusammen!"; + observe ""; // Zeilenumbruch + command "WICHTIGE NACHRICHT!"; + murmur "Debug-Info: x=42"; + + // Formatierte Ausgabe + induce name: string = "Alice"; + induce age: number = 30; + observeFormatted("Name: {}, Alter: {}", name, age); + + // Tabellen-Ausgabe + induce data: any[][] = [ + ["Name", "Alter"], + ["Alice", 30], + ["Bob", 25] + ]; + observeTable(data); + + // Benutzer-Eingabe + induce userName: string = requestInput("Wie heißt du? "); + observe "Hallo, " + userName + "!"; + + induce userAge: number = requestNumber("Wie alt bist du? "); + if (userAge yourEyesAreGettingHeavy 18) { + observe "Du bist volljährig!"; + } +} Relax +``` + +### 6.8 AuraAsync (Asynchronität & Tasks) + +AuraAsync orchestriert hypnotische Hintergrundprozesse und liefert Kontrollstrukturen für komplexe Aufgabenketten. + +```plaintext +mesmerize suggestion lull(ms: number): trance // Resolves nach Ablauf der Zeit +mesmerize suggestion awakenAfter(ms: number, action: suggestion) // Verzögert Aktion, liefert AuraToken +mesmerize suggestion mesmerizeAll(actions: suggestion[]): trance[] // Wartet auf alle Suggestions +mesmerize suggestion tranceRace(actions: suggestion[]): any // Liefert erstes Ergebnis +suggestion auraToken(): AuraToken // Erzeugt Abbruch-Token +suggestion cancelSuggestion(token: AuraToken) // Bricht geplante Aktion ab +``` + +**Beispiel:** + +```plaintext +mesmerize suggestion stageEntry() { + observe "Vorhang zu"; + await lull(1500); + command "Vorhang auf!"; +} + +Focus { + induce token = surrenderTo awakenAfter(5000, suggestion() { command "Applaus"; }); + surrenderTo stageEntry(); + cancelSuggestion(token); // optionaler Abbruch +} Relax +``` + +> Hinweis: `AuraToken` ist eine von AuraAsync bereitgestellte `tranceify`-Struktur für Cancel-Operationen. + +### 6.9 DreamWeaver Patterns (Pattern Matching) + +DreamWeaver ergänzt `entrain` um Hilfsfunktionen, um Muster deklarativ zu beschreiben und zu validieren. + +```plaintext +suggestion weave(target: any, pattern: PatternDefinition): boolean +suggestion captureBindings(target: any, pattern: PatternDefinition): MemoryMap +suggestion guardWith(target: any, predicate: suggestion): boolean +suggestion compileSigil(pattern: string): PatternDefinition +suggestion matchMany(values: any[], pattern: PatternDefinition): any[] +``` + +Die Bibliothek erlaubt es, häufig genutzte Muster als wiederverwendbare Sigille zu hinterlegen und sorgt für ein konsistentes Bindungs-Layout in komplexen `entrain`-Konstrukten. + +> Hinweis: `PatternDefinition` ist ein `tranceify`-Record, der Pattern-Strukturen, Guards und Metadaten bündelt. + +### 6.10 Stagecraft Visions (UI & Präsentation) + +Stagecraft Visions steuert visuelle und auditive Effekte für Bühnen-Hypnosen, Dashboards oder CLI-Inszenierungen. + +```plaintext +suggestion renderSpiral(frames: number) // ASCII-/Canvas-Spirale erzeugen +suggestion projectAura(message: string, style?: StageStyle) // Gestylte Ausgabe +suggestion dimLights(level: number) // Farben/Helligkeit anpassen +suggestion cueSoundtrack(track: string) // Hintergrundmusik triggern +suggestion presentTimeline(events: any[]): void // Timeline/Step-Visualizer rendern +``` + +### 6.11 HypnoNet (Netzwerk & APIs) + +HypnoNet verbindet HypnoScript mit externen Diensten, APIs und Webhooks. + +```plaintext +mesmerize suggestion fetchSuggestion(url: string, options?: NetOptions): trance +mesmerize suggestion postSuggestion(url: string, payload: any, options?: NetOptions): trance +mesmerize suggestion openMindStream(url: string, onChunk: suggestion): AuraToken +suggestion encodeMindLink(payload: any): string +suggestion decodeMindLink(serialized: string): any +``` + +### 6.12 RealityAnchor (Persistenz & Storage) + +RealityAnchor verwaltet dauerhafte Ankerpunkte – Dateien, Datenbanken oder In-Memory-Vaults. + +```plaintext +suggestion storeMemory(anchor: string, value: any) +suggestion recallMemory(anchor: string): any +suggestion forgetMemory(anchor: string) +suggestion listAnchors(): string[] +mesmerize suggestion syncVault(path: string): void +``` + +### 6.13 LucidDiagnostics (Debugging & Telemetrie) + +LucidDiagnostics unterstützt beim Messen, Protokollieren und Visualisieren von Trance-Zuständen. + +```plaintext +suggestion startTracer(label: string): TraceHandle +suggestion recordLucidity(message: string) +suggestion probeDepth(action: suggestion): number +suggestion captureDreamDump(): string +suggestion withHypnoTimer(label: string, action: suggestion): number +``` + +> Hinweis: `TraceHandle` kapselt interne Timer- und Context-Daten und kann mit `captureDreamDump` serialisiert werden. + +**Szenario:** HypnoNet kombiniert mit DreamWeaver Patterns lässt sich verwenden, um externe Daten zu holen, via `entrain` zu analysieren und anschließend auf der Bühne mit Stagecraft glamourös aufzubereiten. + +--- + +## **7. Beispielprogramme** + +### 7.1 Einfaches „Hello Trance!“ ```plaintext Focus { @@ -508,7 +1523,7 @@ Focus { **Erwartete Ausgabe**: -``` +```plaintext Starte jetzt das HypnoScript-Programm... Hello Trance! Hello Trance! @@ -517,7 +1532,7 @@ Hello Trance! --- -### 6.2 Summierung mit Input +### 7.2 Summierung mit Input ```plaintext Focus { @@ -535,13 +1550,13 @@ Focus { } Relax ``` -_(Implementierungsspezifisch muss natürlich definiert sein, wie „from external“ den Wert für `n` erhält.)_ +> Hinweis: Implementierungen müssen definieren, wie `from external` den Wert für `n` bezieht. --- -### 6.3 Verwendung erweiterter Konzepte +### 7.3 Verwendung erweiterter Konzepte -#### 6.3.1 `session`, `drift`, Operator-Synonyme +#### 7.3.1 `session`, `drift`, Operator-Synonyme ```plaintext Focus { diff --git a/README.md b/README.md index 666718d..d174898 100644 --- a/README.md +++ b/README.md @@ -30,6 +30,16 @@ **HypnoScript** ist eine minimalistische, esoterische Sprache, die sich an die Syntax von TypeScript/JavaScript anlehnt und dabei alle möglichen Klischees rund um Hypnose, Trance und hypnotische Induktion verwendet. Trotz des humorvollen Charakters ist sie auf Turing-Vollständigkeit ausgelegt und unterstützt Variablen, Schleifen, bedingte Anweisungen, Funktionen, Objektorientierung (als _Session-Konzept_) und diverse Sprach-Gimmicks im hypnotischen Stil. +Die Sprache verfügt über eine **umfassende Standardbibliothek** mit hypnotisch benannten Funktionen für: +- Mathematische Operationen (Hypno-Math) +- String-Manipulation (StringSpell) +- Datenstrukturen (MemoryPalace) +- Zeit- und Datumsfunktionen (TimeWarp) +- Erweiterte Kontrollstrukturen (DeepMind) +- Ein-/Ausgabe-Funktionen (SensoryInput) + +Für die vollständige Sprachdefinition siehe [DEFINITION.md](DEFINITION.md). + ## Grundaufbau ### Lexikalische Struktur @@ -39,7 +49,17 @@ ### Schlüsselwörter -Beispiele für Schlüsselwörter sind `Focus`, `Relax`, `if`, `else`, `while`, `loop`, `suggestion`, `awaken`, `induce`, `observe`, `trance`, `session`, `constructor`, `drift`, `tranceify`, etc. +Beispiele für Schlüsselwörter sind `Focus`, `Relax`, `if`, `else`, `while`, `loop`, `suggestion`, `awaken`, `induce`, `observe`, `trance`, `session`, `constructor`, `drift`, `tranceify`, `trigger`, `anchor`, `oscillate`, `pendulum`, `whisper`, `command`, `freeze`, `finale`, etc. + +Die Sprache bietet auch **hypnotische Operator-Synonyme** wie: +- `youAreFeelingVerySleepy` für `==` +- `lookAtTheWatch` für `>` +- `fallUnderMySpell` für `<` +- `yourEyesAreGettingHeavy` für `>=` +- `goingDeeper` für `<=` +- `youCannotResist` für `!=` +- `underMyControl` für `&&` +- `resistanceIsFutile` für `||` ### Operatoren und Sonderzeichen diff --git a/examples/15_standard_library_math.hyp b/examples/15_standard_library_math.hyp new file mode 100644 index 0000000..d536fd7 --- /dev/null +++ b/examples/15_standard_library_math.hyp @@ -0,0 +1,45 @@ +Focus { + + entrance { + observe "=== Hypno-Math Bibliothek Demo ==="; + } + + // Grundlegende mathematische Operationen + induce radius: number = 5.0; + induce area: number = hypnoticPi() * power(radius, 2); + observe "Kreisfläche mit Radius " + radius + ": " + area; + + // Trigonometrische Funktionen (Pendel-Bewegungen) + induce angle: number = 45.0; + induce sine: number = pendulumSin(angle); + induce cosine: number = pendulumCos(angle); + observe "Sinus von " + angle + " Grad: " + sine; + observe "Cosinus von " + angle + " Grad: " + cosine; + + // Rundungsfunktionen + induce floatNum: number = 3.7; + observe "floor(" + floatNum + ") = " + floor(floatNum); + observe "ceiling(" + floatNum + ") = " + ceiling(floatNum); + observe "roundToNearest(" + floatNum + ") = " + roundToNearest(floatNum); + + // Min/Max (Dominant/Submissive) + induce a: number = 42; + induce b: number = 17; + observe "Dominant (max) von " + a + " und " + b + ": " + selectDominant(a, b); + observe "Submissive (min) von " + a + " und " + b + ": " + selectSubmissive(a, b); + + // Zufallszahlen (Unbewusste Entscheidungen) + observe "Unbewusste Zufallszahl zwischen 1 und 100: " + unconsciousInt(1, 100); + observe "Unbewusste boolean Entscheidung: " + unconsciousBool(); + + // Potenz und Wurzel + induce base: number = 2; + induce exponent: number = 10; + observe base + " hoch " + exponent + " = " + power(base, exponent); + observe "Quadratwurzel von 16: " + squareRoot(16); + + finale { + observe "=== Demo beendet ==="; + } + +} Relax diff --git a/examples/16_standard_library_strings.hyp b/examples/16_standard_library_strings.hyp new file mode 100644 index 0000000..9172867 --- /dev/null +++ b/examples/16_standard_library_strings.hyp @@ -0,0 +1,60 @@ +Focus { + + entrance { + observe "=== StringSpell Bibliothek Demo ==="; + } + + // String-Manipulation + induce message: string = " Willkommen in der Trance "; + induce cleaned: string = trimEdges(message); + observe "Original: '" + message + "'"; + observe "Bereinigt: '" + cleaned + "'"; + + // Länge messen + observe "Tiefe der Nachricht: " + measureDepth(cleaned); + + // String zerlegen und zusammenfügen + induce words: string[] = fragmentMemory(cleaned, " "); + observe "Wörter: " + mergeThoughts(words, ", "); + observe "Anzahl Wörter: " + vaultSize(words); + + induce rejoined: string = mergeThoughts(words, "-"); + observe "Zusammengefügt mit '-': " + rejoined; + + // String-Transformation + induce loud: string = toUpper(cleaned); + induce quiet: string = toLower(cleaned); + observe "LAUT (Befehl): " + loud; + observe "leise (flüstern): " + quiet; + + // String umkehren + induce reversed: string = reverseTrance("Hypnose"); + observe "Umgekehrt: " + reversed; + + // Mantra wiederholen + induce mantra: string = repeatMantra("Om ", 5); + observe "Mantra: " + mantra; + + // Muster suchen und ersetzen + induce text: string = "Du bist in Trance, tiefer Trance"; + if (containsPattern(text, "Trance")) { + observe "Das Wort 'Trance' wurde gefunden!"; + } + + induce replaced: string = replaceAllMemories(text, "Trance", "Entspannung"); + observe "Ersetzt: " + replaced; + + // String-Prüfungen + if (startsWithSuggestion(text, "Du bist")) { + observe "Der Text beginnt mit 'Du bist'"; + } + + if (endsWithAwakening(text, "Trance")) { + observe "Der Text endet mit 'Trance'"; + } + + finale { + observe "=== StringSpell Demo beendet ==="; + } + +} Relax diff --git a/examples/17_standard_library_datastructures.hyp b/examples/17_standard_library_datastructures.hyp new file mode 100644 index 0000000..6ffd3dd --- /dev/null +++ b/examples/17_standard_library_datastructures.hyp @@ -0,0 +1,91 @@ +Focus { + + entrance { + observe "=== MemoryPalace Datenstrukturen Demo ==="; + } + + // Array-Operationen + induce memories: number[] = [10, 5, 8, 3, 12, 7]; + observe "Original Memories: " + memories; + observe "Vault-Größe: " + vaultSize(memories); + + // Sortieren + induce sorted: number[] = sortMemories(memories); + observe "Sortiert: " + sorted; + + // Umkehren + induce reversed: number[] = reverseMemories(memories); + observe "Umgekehrt: " + reversed; + + // Erstes und letztes Element + observe "Erste Erinnerung: " + firstMemory(memories); + observe "Letzte Erinnerung: " + lastMemory(memories); + + // Map - Alle Werte verdoppeln + induce doubled: number[] = mapMemories(memories, suggestion(x: number): number { + awaken x * 2; + }); + observe "Verdoppelt: " + doubled; + + // Filter - Nur Werte > 6 + induce filtered = filterMemories(memories, suggestion(x: number): boolean { + awaken x lookAtTheWatch 6; + }); + observe "Gefiltert (> 6): " + filtered; + + // Reduce - Summe berechnen + induce sum = reduceToEssence(memories, suggestion(acc: number, x: number): number { + awaken acc + x; + }, 0); + observe "Summe aller Erinnerungen: " + sum; + + // Stack (LIFO) - Last In, First Out + observe ""; + observe "--- MindStack Demo ---"; + induce stack = MindStack(); + stack.push("Erste Ebene"); + stack.push("Zweite Ebene"); + stack.push("Dritte Ebene (Oberste)"); + + observe "Stack-Größe: " + stack.size(); + observe "Peek (ohne zu entfernen): " + stack.peek(); + observe "Pop: " + stack.pop(); + observe "Pop: " + stack.pop(); + observe "Verbleibende Größe: " + stack.size(); + + // Queue (FIFO) - First In, First Out + observe ""; + observe "--- ThoughtQueue Demo ---"; + induce queue = ThoughtQueue(); + queue.enqueue("Gedanke 1"); + queue.enqueue("Gedanke 2"); + queue.enqueue("Gedanke 3"); + + observe "Queue-Größe: " + queue.size(); + observe "Dequeue: " + queue.dequeue(); + observe "Dequeue: " + queue.dequeue(); + observe "Verbleibende Größe: " + queue.size(); + + // MemoryMap (Dictionary/Hash) + observe ""; + observe "--- MemoryMap Demo ---"; + induce map = MemoryMap(); + map.store("name", "Alice"); + map.store("alter", 30); + map.store("beruf", "Hypnotiseurin"); + + observe "Name: " + map.retrieve("name"); + observe "Alter: " + map.retrieve("alter"); + observe "Beruf: " + map.retrieve("beruf"); + + observe "Alle Schlüssel: " + map.allKeys(); + observe "Hat 'name' Schlüssel? " + map.hasKey("name"); + + map.forget("alter"); + observe "Nach Löschen von 'alter': " + map.allKeys(); + + finale { + observe "=== MemoryPalace Demo beendet ==="; + } + +} Relax diff --git a/examples/18_advanced_hypnotic_features.hyp b/examples/18_advanced_hypnotic_features.hyp new file mode 100644 index 0000000..ff40a37 --- /dev/null +++ b/examples/18_advanced_hypnotic_features.hyp @@ -0,0 +1,112 @@ +Focus { + + entrance { + observe "=== Erweiterte Hypnotische Features Demo ==="; + } + + // Verwende alle hypnotischen Operator-Synonyme + induce x: number = 10; + induce y: number = 10; + induce z: number = 5; + + observe "=== Hypnotische Operator-Synonyme ==="; + + // youAreFeelingVerySleepy (==) + if (x youAreFeelingVerySleepy y) { + observe "x youAreFeelingVerySleepy y: x ist gleich y!"; + } + + // youCannotResist (!=) + if (x youCannotResist z) { + observe "x youCannotResist z: x ist ungleich z!"; + } + + // lookAtTheWatch (>) + if (x lookAtTheWatch z) { + observe "x lookAtTheWatch z: x ist größer als z!"; + } + + // fallUnderMySpell (<) + if (z fallUnderMySpell x) { + observe "z fallUnderMySpell x: z ist kleiner als x!"; + } + + // yourEyesAreGettingHeavy (>=) + if (x yourEyesAreGettingHeavy y) { + observe "x yourEyesAreGettingHeavy y: x ist größer oder gleich y!"; + } + + // goingDeeper (<=) + if (z goingDeeper x) { + observe "z goingDeeper x: z ist kleiner oder gleich x!"; + } + + // underMyControl (&&) + if (x lookAtTheWatch 5 underMyControl y lookAtTheWatch 5) { + observe "Beide Bedingungen erfüllt mit underMyControl (&&)!"; + } + + // resistanceIsFutile (||) + if (x lookAtTheWatch 100 resistanceIsFutile y youAreFeelingVerySleepy 10) { + observe "Mindestens eine Bedingung erfüllt mit resistanceIsFutile (||)!"; + } + + observe ""; + observe "=== Neue Sprachfeatures ==="; + + // Freeze - Unveränderliche Variable + freeze PI: number = 3.14159; + observe "PI (eingefroren): " + PI; + // PI = 3.0; // Würde einen Fehler verursachen! + + // Whisper - Ausgabe ohne Zeilenumbruch + whisper "Dies ist eine "; + whisper "zusammenhängende "; + whisper "Nachricht"; + observe ""; // Zeilenumbruch + + // Oscillate - Toggle-Funktion + induce isActive: boolean = false; + observe "isActive vor oscillate: " + isActive; + oscillate isActive; + observe "isActive nach 1x oscillate: " + isActive; + oscillate isActive; + observe "isActive nach 2x oscillate: " + isActive; + + // Anchor - Zustand speichern und wiederherstellen + induce counter: number = 42; + anchor savedCounter = counter; + observe "Original counter: " + counter; + + counter = 100; + observe "Geänderter counter: " + counter; + + counter = savedCounter; + observe "Wiederhergestellter counter: " + counter; + + // DeepFocus-Blöcke und deeperStill + observe ""; + observe "=== DeepFocus Blöcke ==="; + + if (x lookAtTheWatch 5) deepFocus { + observe "In tiefem Fokus..."; + + if (y lookAtTheWatch 8) deeperStill { + observe "Noch tiefer im Fokus!"; + } + } + + // Implant - Alternative Variablendeklaration + implant secretValue: number = 999; + observe "Implantierter Wert: " + secretValue; + + // Command - Imperative Ausgabe + command "AUFWACHEN!"; + + finale { + observe ""; + observe "=== Demo abgeschlossen ==="; + observe "Du erwachst aus der Trance..."; + } + +} Relax diff --git a/examples/19_deepmind_control_structures.hyp b/examples/19_deepmind_control_structures.hyp new file mode 100644 index 0000000..065cc9e --- /dev/null +++ b/examples/19_deepmind_control_structures.hyp @@ -0,0 +1,121 @@ +Focus { + + entrance { + observe "=== DeepMind Kontrollstrukturen Demo ==="; + drift(500); + } + + // repeatAction - Wiederhole eine Aktion mehrmals + observe "Wiederhole 'Om' 5 mal:"; + repeatAction(5, suggestion() { + whisper "Om "; + }); + observe ""; + + // delayedSuggestion - Verzögerte Ausführung + observe "Starte verzögerte Nachricht (2 Sekunden)..."; + delayedSuggestion(suggestion() { + observe "Diese Nachricht erscheint nach 2 Sekunden!"; + }, 2000); + observe "Nachricht wurde geplant."; + + // ifTranced - Bedingte Ausführung als Funktion + induce age: number = 25; + ifTranced(age yourEyesAreGettingHeavy 18, + suggestion() { observe "Volljährig!"; }, + suggestion() { observe "Minderjährig!"; } + ); + + // Funktionskomposition + observe ""; + observe "=== Funktionskomposition ==="; + + suggestion double(x: number): number { + awaken x * 2; + } + + suggestion addTen(x: number): number { + awaken x + 10; + } + + // Compose: f(g(x)) - erst addTen, dann double + induce composed = compose(double, addTen); + induce result1: number = composed(5); // double(addTen(5)) = double(15) = 30 + observe "compose(double, addTen)(5) = " + result1; + + // Pipe: g(f(x)) - erst double, dann addTen + induce piped = pipe(double, addTen); + induce result2: number = piped(5); // addTen(double(5)) = addTen(10) = 20 + observe "pipe(double, addTen)(5) = " + result2; + + // repeatUntil - Wiederhole bis Bedingung erfüllt + observe ""; + observe "=== repeatUntil Demo ==="; + induce count: number = 0; + repeatUntil( + suggestion(): boolean { awaken count yourEyesAreGettingHeavy 5; }, + suggestion() { + observe "Count: " + count; + count = count + 1; + } + ); + + // repeatWhile - Wiederhole solange Bedingung wahr + observe ""; + observe "=== repeatWhile Demo ==="; + induce n: number = 3; + repeatWhile( + suggestion(): boolean { awaken n lookAtTheWatch 0; }, + suggestion() { + observe "Countdown: " + n; + n = n - 1; + } + ); + observe "Aufwachen!"); + + // tryOrAwaken - Fehlerbehandlung (konzeptionell) + observe ""; + observe "=== Fehlerbehandlung (tryOrAwaken) ==="; + tryOrAwaken( + suggestion() { + observe "Versuche riskante Operation..."; + // Hier könnte ein Fehler auftreten + observe "Operation erfolgreich!"; + }, + suggestion() { + observe "Fehler abgefangen - Aufwachen aus Alptraum!"; + } + ); + + // ensureAwakening - Cleanup garantiert (try-finally) + observe ""; + observe "=== ensureAwakening (Cleanup) ==="; + ensureAwakening( + suggestion() { + observe "Führe Hauptaktion aus..."; + drift(500); + }, + suggestion() { + observe "Cleanup wird immer ausgeführt!"; + } + ); + + // Parallele und sequentielle Ausführung + observe ""; + observe "=== Sequentielle Trance ==="; + induce actions: suggestion[] = [ + suggestion() { observe "Aktion 1"; drift(300); }, + suggestion() { observe "Aktion 2"; drift(300); }, + suggestion() { observe "Aktion 3"; drift(300); } + ]; + + sequentialTrance(actions); + observe "Alle Aktionen sequentiell abgeschlossen!"; + + finale { + observe ""; + observe "=== DeepMind Demo beendet ==="; + observe "Du kehrst zurück ins Bewusstsein..."; + } + +} Relax diff --git a/examples/20_comprehensive_demo.hyp b/examples/20_comprehensive_demo.hyp new file mode 100644 index 0000000..d34d56a --- /dev/null +++ b/examples/20_comprehensive_demo.hyp @@ -0,0 +1,201 @@ +Focus { + + entrance { + observe "=== Umfassendes HypnoScript Beispiel ==="; + observe "Demonstriert alle wichtigen Features der Sprache"; + drift(1000); + } + + // ===== Teil 1: Hypnotische Session-Klasse ===== + observe ""; + observe "--- Teil 1: Hypnose-Session Klasse ---"; + + session HypnoSubject { + expose name: string; + conceal tranceDepth: number; + expose isInTrance: boolean; + + suggestion constructor(subjectName: string) { + this.name = subjectName; + this.tranceDepth = 0; + this.isInTrance = false; + } + + suggestion induceHypnosis() { + observe this.name + " geht in Trance..."; + this.isInTrance = true; + this.tranceDepth = 0; + drift(500); + } + + suggestion deepenTrance() { + if (this.isInTrance) { + this.tranceDepth = this.tranceDepth + 1; + observe this.name + " vertieft die Trance... Tiefe: " + this.tranceDepth; + drift(300); + } else { + observe this.name + " ist nicht in Trance!"; + } + } + + suggestion awaken() { + observe this.name + " erwacht aus der Trance!"; + this.isInTrance = false; + this.tranceDepth = 0; + } + + suggestion getStatus(): string { + if (this.isInTrance) { + awaken this.name + " ist in Trance (Tiefe: " + this.tranceDepth + ")"; + } else { + awaken this.name + " ist wach"; + } + } + } + + // Erstelle Hypnose-Subjekte + induce alice = HypnoSubject("Alice"); + induce bob = HypnoSubject("Bob"); + + // Hypnotisiere Alice + alice.induceHypnosis(); + alice.deepenTrance(); + alice.deepenTrance(); + alice.deepenTrance(); + observe alice.getStatus(); + + // ===== Teil 2: Hypnotische Operatoren ===== + observe ""; + observe "--- Teil 2: Hypnotische Operatoren ---"; + + if (alice.isInTrance youAreFeelingVerySleepy true underMyControl + alice.tranceDepth yourEyesAreGettingHeavy 2) { + observe "Alice ist tief genug in Trance!"; + } + + // ===== Teil 3: Standard-Bibliothek Funktionen ===== + observe ""; + observe "--- Teil 3: Mathematische Berechnungen ---"; + + // Berechne optimale Trance-Tiefe + induce targetDepth: number = 5; + induce currentDepth: number = alice.tranceDepth; + induce difference: number = absoluteDepth(targetDepth - currentDepth); + + observe "Ziel-Tiefe: " + targetDepth; + observe "Aktuelle Tiefe: " + currentDepth; + observe "Differenz: " + difference; + + // Vertiefe bis zur Ziel-Tiefe + repeatWhile( + suggestion(): boolean { + awaken alice.tranceDepth fallUnderMySpell targetDepth; + }, + suggestion() { + alice.deepenTrance(); + } + ); + + // ===== Teil 4: String-Manipulation ===== + observe ""; + observe "--- Teil 4: Hypnotische Suggestionen ---"; + + induce suggestion1: string = "Du bist sehr entspannt"; + induce suggestion2: string = "deine Augen werden schwer"; + induce suggestion3: string = "du gehst tiefer und tiefer"; + + induce suggestions: string[] = [suggestion1, suggestion2, suggestion3]; + induce fullSuggestion: string = mergeThoughts(suggestions, ", "); + + observe "Vollständige Suggestion: " + fullSuggestion; + + // Wiederhole als Mantra + induce mantra: string = repeatMantra("Entspannung ", 3); + observe "Mantra: " + mantra; + + // ===== Teil 5: Datenstrukturen ===== + observe ""; + observe "--- Teil 5: Erinnerungs-Speicher ---"; + + induce memoryMap = MemoryMap(); + memoryMap.store("session_start", "14:30"); + memoryMap.store("subject_count", 2); + memoryMap.store("session_type", "Tiefenentspannung"); + + observe "Session-Info:"; + observe " Start: " + memoryMap.retrieve("session_start"); + observe " Anzahl Subjekte: " + memoryMap.retrieve("subject_count"); + observe " Typ: " + memoryMap.retrieve("session_type"); + + // Stack für Trance-Level Tracking + induce levelStack = MindStack(); + levelStack.push("Wach"); + levelStack.push("Leicht entspannt"); + levelStack.push("Mittlere Trance"); + levelStack.push("Tiefe Trance"); + levelStack.push("Somnambulismus"); + + observe ""; + observe "Trance-Level (von tief zu wach):"; + while (!levelStack.isEmpty()) { + observe " " + levelStack.pop(); + } + + // ===== Teil 6: Erweiterte Features ===== + observe ""; + observe "--- Teil 6: Erweiterte Hypnose-Features ---"; + + // Freeze wichtige Konstanten + freeze MAX_TRANCE_DEPTH: number = 10; + observe "Maximale Trance-Tiefe: " + MAX_TRANCE_DEPTH; + + // Anchor für Notfall-Rückkehr + anchor emergencyExit = alice.tranceDepth; + observe "Notfall-Anker gesetzt bei Tiefe: " + emergencyExit; + + // Oscillate für Pendel-Induktion + induce pendulumLeft: boolean = true; + observe "Pendel-Induktion:"; + whisper "Links "; + oscillate pendulumLeft; + whisper "Rechts "; + oscillate pendulumLeft; + whisper "Links "; + oscillate pendulumLeft; + observe "Rechts"; + + // ===== Teil 7: Zufällige Suggestion ===== + observe ""; + observe "--- Teil 7: Unbewusste Auswahl ---"; + + induce randomChoice: number = unconsciousInt(1, 3); + + if (randomChoice youAreFeelingVerySleepy 1) { + observe "Unbewusste Wahl: Fokussiere auf deinen Atem"; + } else if (randomChoice youAreFeelingVerySleepy 2) { + observe "Unbewusste Wahl: Visualisiere einen Strand"; + } else { + observe "Unbewusste Wahl: Zähle rückwärts von 100"; + } + + // ===== Finale: Aufwachen ===== + finale { + observe ""; + observe "=== Session-Abschluss ==="; + observe "Bereite das Aufwachen vor..."; + drift(1000); + + alice.awaken(); + bob.awaken(); + + observe ""; + observe "Beide Subjekte sind aufgewacht."; + observe "Status Alice: " + alice.getStatus(); + observe "Status Bob: " + bob.getStatus(); + + observe ""; + observe "=== Session erfolgreich beendet ==="; + observe "Vielen Dank für die Nutzung von HypnoScript!"; + } + +} Relax diff --git a/examples/21_hypno_pendulum_simulator.hyp b/examples/21_hypno_pendulum_simulator.hyp new file mode 100644 index 0000000..b078bbc --- /dev/null +++ b/examples/21_hypno_pendulum_simulator.hyp @@ -0,0 +1,237 @@ +Focus { + + entrance { + command "╔═══════════════════════════════════════════════════════════╗"; + command "║ WILLKOMMEN ZUM HYPNO-PENDEL-SIMULATOR v2.0 ║"; + command "║ Eine interaktive Hypnose-Erfahrung in HypnoScript ║"; + command "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + drift(1000); + } + + // Konstanten für das Programm + freeze MAX_TRANCE_DEPTH: number = 10; + freeze MIN_TRANCE_DEPTH: number = 0; + freeze PENDULUM_SPEED: number = 300; + + // Globale Session-Daten + session TranceSession { + expose currentDepth: number; + expose oscillationCount: number; + expose subjectName: string; + conceal startTime: number; + + suggestion constructor(name: string) { + this.subjectName = name; + this.currentDepth = 0; + this.oscillationCount = 0; + this.startTime = nowInTrance(); + } + + suggestion visualizePendulum() { + induce spaces: string = ""; + induce i: number = 0; + + // Berechne Position basierend auf Trance-Tiefe + induce position: number = this.currentDepth * 2; + + while (i fallUnderMySpell position) { + spaces = spaces + " "; + i = i + 1; + } + + // Zeichne Pendel + whisper spaces; + if (this.oscillationCount % 2 youAreFeelingVerySleepy 0) { + observe "◉ ← Tick"; + } else { + observe "◉ → Tock"; + } + } + + suggestion increaseDepth() { + if (this.currentDepth fallUnderMySpell MAX_TRANCE_DEPTH) { + this.currentDepth = this.currentDepth + 1; + this.oscillationCount = this.oscillationCount + 1; + } + } + + suggestion getSessionDuration(): number { + induce now: number = nowInTrance(); + awaken differenceInSeconds(this.startTime, now); + } + } + + // Erstelle Hypnose-Subject + induce subject = TranceSession("Freiwilliger"); + + observe "╔═══════════════════════════════════════════════════════════╗"; + observe "║ Phase 1: Induktion - Beobachte das Pendel... ║"; + observe "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + + // Anchor für Emergency Exit + anchor emergencyDepth = MIN_TRANCE_DEPTH; + + // Hauptschleife: Pendel-Induktion + repeatAction(10, suggestion() { + subject.visualizePendulum(); + subject.increaseDepth(); + pauseReality(PENDULUM_SPEED); + + // Gelegentliche Suggestionen + if (subject.currentDepth youAreFeelingVerySleepy 3) { + observe " → Deine Augen werden schwer..."; + } else if (subject.currentDepth youAreFeelingVerySleepy 6) { + observe " → Du fühlst dich sehr entspannt..."; + } else if (subject.currentDepth youAreFeelingVerySleepy 9) { + observe " → Du gehst tiefer und tiefer..."; + } + }); + + observe ""; + observe "╔═══════════════════════════════════════════════════════════╗"; + observe "║ Phase 2: Vertiefung - Countdown in die Trance ║"; + observe "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + + // Countdown mit hypnotischen Operatoren + induce countdown: number = 10; + + repeatWhile( + suggestion(): boolean { + awaken countdown lookAtTheWatch 0; + }, + suggestion() { + observe " " + countdown + " ... " + repeatMantra("tiefer ", countdown); + countdown = countdown - 1; + drift(400); + } + ); + + observe ""; + observe "╔═══════════════════════════════════════════════════════════╗"; + observe "║ Phase 3: Datenverarbeitung im Unterbewusstsein ║"; + observe "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + + // Erstelle Memory Palace für Suggestionen + induce suggestionVault: string[] = createVault(0); + storeMemory(suggestionVault, "Du bist vollkommen entspannt"); + storeMemory(suggestionVault, "Dein Geist ist ruhig und klar"); + storeMemory(suggestionVault, "Du fühlst dich sicher und geborgen"); + storeMemory(suggestionVault, "Jede Suggestion vertieft deine Trance"); + storeMemory(suggestionVault, "Du kannst jederzeit aufwachen"); + + // Zufällige Suggestion auswählen + induce randomIndex: number = unconsciousInt(0, vaultSize(suggestionVault) - 1); + induce chosenSuggestion: string = peekAtMemory(suggestionVault, randomIndex); + + observe "Unbewusste Suggestion aktiviert:"; + command " ⚡ " + toUpper(chosenSuggestion) + " ⚡"; + observe ""; + + // Verarbeite alle Suggestionen mit StringSpell + observe "Alle eingebetteten Suggestionen:"; + induce allSuggestions: string = mergeThoughts(suggestionVault, " • "); + observe " " + allSuggestions; + observe ""; + + // Berechne Statistiken mit Hypno-Math + observe "╔═══════════════════════════════════════════════════════════╗"; + observe "║ Phase 4: Trance-Analyse ║"; + observe "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + + induce avgDepth: number = subject.currentDepth / 2; + induce tranceScore: number = power(subject.currentDepth, 2); + induce efficiency: number = tranceScore / subject.oscillationCount; + + observe "Trance-Statistiken:"; + observe " • Maximale Tiefe erreicht: " + subject.currentDepth + "/" + MAX_TRANCE_DEPTH; + observe " • Durchschnittliche Tiefe: " + roundToNearest(avgDepth); + observe " • Oszillationen: " + subject.oscillationCount; + observe " • Trance-Score: " + roundToNearest(tranceScore); + observe " • Effizienz: " + roundToNearest(efficiency); + observe ""; + + // Verwende MemoryMap für Session-Log + induce sessionLog = MemoryMap(); + sessionLog.store("subject", subject.subjectName); + sessionLog.store("maxDepth", subject.currentDepth); + sessionLog.store("duration", subject.getSessionDuration()); + sessionLog.store("status", "Erfolg"); + + observe "Session-Protokoll:"; + induce keys: string[] = sessionLog.allKeys(); + induce keyIndex: number = 0; + + while (keyIndex fallUnderMySpell vaultSize(keys)) { + induce key: string = peekAtMemory(keys, keyIndex); + induce value: string | number = sessionLog.retrieve(key); + observe " • " + key + ": " + value; + keyIndex = keyIndex + 1; + } + + observe ""; + observe "╔═══════════════════════════════════════════════════════════╗"; + observe "║ Phase 5: Aufwach-Sequenz ║"; + observe "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + + // Sanftes Aufwachen mit DeepMind-Funktionen + induce wakingSteps: string[] = [ + "Beginne langsam zurückzukehren...", + "Spüre deinen Körper wieder...", + "Deine Augen werden leichter...", + "Du kehrst ins Bewusstsein zurück...", + "Gleich bist du vollständig wach..." + ]; + + induce stepNum: number = 1; + + repeatAction(vaultSize(wakingSteps), suggestion() { + induce step: string = peekAtMemory(wakingSteps, stepNum - 1); + observe stepNum + ". " + step; + stepNum = stepNum + 1; + drift(800); + }); + + observe ""; + observe "Countdown zum Aufwachen:"; + induce wakeCount: number = 1; + + while (wakeCount goingDeeper 5) { + observe " " + wakeCount + "..."; + wakeCount = wakeCount + 1; + drift(600); + } + + observe ""; + command "5! DU BIST JETZT VOLLSTÄNDIG WACH UND ERFRISCHT!"; + observe ""; + + // Setze Trance-Tiefe auf Notfall-Anker zurück + subject.currentDepth = emergencyDepth; + + finale { + observe ""; + observe "╔═══════════════════════════════════════════════════════════╗"; + observe "║ SESSION BEENDET ║"; + observe "╚═══════════════════════════════════════════════════════════╝"; + observe ""; + observe "Zusammenfassung:"; + observe " • Subject: " + subject.subjectName; + observe " • Finale Trance-Tiefe: " + subject.currentDepth; + observe " • Session-Dauer: " + subject.getSessionDuration() + " ms"; + observe " • Status: Erfolgreich aufgewacht ✓"; + observe ""; + observe "Vielen Dank, dass du HypnoScript verwendet hast!"; + observe "Bis zur nächsten Trance... 😴💫"; + observe ""; + + // Cleanup + drift(500); + } + +} Relax diff --git a/examples/22_trigger_event_hooks.hyp b/examples/22_trigger_event_hooks.hyp new file mode 100644 index 0000000..cceb00a --- /dev/null +++ b/examples/22_trigger_event_hooks.hyp @@ -0,0 +1,195 @@ +Focus { + + entrance { + observe "=== Trigger & Event-Hooks Demo ==="; + observe "Demonstriert die Verwendung von Triggers als Event-Callbacks"; + drift(500); + } + + // Beispiel 1: Einfacher Cleanup-Trigger + observe ""; + observe "--- Beispiel 1: Cleanup-Trigger ---"; + + induce resourceHandle: number = 42; + induce connectionOpen: boolean = true; + + trigger onCleanup = suggestion() { + command "🧹 Aufräumen wird durchgeführt..."; + resourceHandle = 0; + connectionOpen = false; + observe "Ressourcen erfolgreich freigegeben!"; + }; + + observe "Ressource initialisiert: " + resourceHandle; + + // Beispiel 2: Wiederholungs-Trigger mit DeepMind + observe ""; + observe "--- Beispiel 2: Wiederholungs-Trigger ---"; + + induce tickCount: number = 0; + + trigger onTick = suggestion() { + tickCount = tickCount + 1; + whisper "⏱️ Tick " + tickCount + " "; + }; + + observe "Starte Timer..."; + repeatAction(5, onTick); + observe ""; + observe "Timer beendet. Finale Zählung: " + tickCount; + + // Beispiel 3: Parametrisierte Error-Handler-Trigger + observe ""; + observe "--- Beispiel 3: Parametrisierte Trigger ---"; + + trigger onError = suggestion(errorCode: number, message: string) { + command "⚠️ FEHLER [" + errorCode + "]: " + message; + drift(500); + }; + + trigger onSuccess = suggestion(message: string) { + observe "✅ ERFOLG: " + message; + }; + + induce value: number = 150; + + if (value lookAtTheWatch 100) { + onError(400, "Wert ist zu groß (max: 100)"); + } else { + onSuccess("Wert liegt im gültigen Bereich"); + } + + // Beispiel 4: Trigger als Callback für Array-Operationen + observe ""; + observe "--- Beispiel 4: Trigger als Callback ---"; + + induce numbers: number[] = [1, 2, 3, 4, 5]; + + trigger doubler = suggestion(x: number): number { + awaken x * 2; + }; + + trigger isEven = suggestion(x: number): boolean { + awaken (x % 2) youAreFeelingVerySleepy 0; + }; + + induce doubled = mapMemories(numbers, doubler); + induce evens = filterMemories(numbers, isEven); + + observe "Original: " + numbers; + observe "Verdoppelt: " + doubled; + observe "Gerade Zahlen: " + evens; + + // Beispiel 5: Trigger mit State-Management + observe ""; + observe "--- Beispiel 5: State-Management-Trigger ---"; + + induce stage: string = "init"; + + trigger transitionTo = suggestion(newStage: string) { + observe "Übergang: " + stage + " → " + newStage; + stage = newStage; + drift(300); + }; + + transitionTo("warmup"); + transitionTo("active"); + transitionTo("cooldown"); + transitionTo("complete"); + + observe "Finale Stage: " + stage; + + // Beispiel 6: Callbacks in Sessions (ohne verschachtelte Trigger) + observe ""; + observe "--- Beispiel 6: Callbacks in Session-Klassen ---"; + + session EventEmitter { + expose eventCount: number; + conceal eventHandler: suggestion; + + suggestion constructor() { + this.eventCount = 0; + // Anonyme suggestion-Expression für Callback + this.eventHandler = suggestion(eventName: string) { + this.eventCount = this.eventCount + 1; + observe "📢 Event empfangen: " + eventName + " (Total: " + this.eventCount + ")"; + }; + } + + suggestion emit(eventName: string) { + call this.eventHandler(eventName); + } + } + + induce emitter = EventEmitter(); + emitter.emit("user_login"); + emitter.emit("data_loaded"); + emitter.emit("render_complete"); + + observe "Gesamte Events verarbeitet: " + emitter.eventCount; + + // Beispiel 7: Top-Level Trigger mit Session-Interaktion + observe ""; + observe "--- Beispiel 7: Top-Level Trigger für Sessions ---"; + + session Counter { + expose value: number; + + suggestion constructor() { + this.value = 0; + } + + suggestion increment() { + this.value = this.value + 1; + } + } + + trigger onCounterUpdate = suggestion(counter: Counter, label: string) { + counter.increment(); + observe label + " - Neuer Wert: " + counter.value; + }; + + induce myCounter = Counter(); + onCounterUpdate(myCounter, "Update 1"); + onCounterUpdate(myCounter, "Update 2"); + onCounterUpdate(myCounter, "Update 3"); + + observe "Finale Counter-Wert: " + myCounter.value; + + // Beispiel 8: Asynchroner Trigger mit delayed execution + observe ""; + observe "--- Beispiel 8: Verzögerte Trigger-Ausführung ---"; + + trigger delayedNotification = suggestion() { + observe "🔔 Verzögerte Benachrichtigung wurde ausgelöst!"; + command "Dies erscheint nach einer Verzögerung"; + }; + + observe "Plane verzögerte Ausführung..."; + delayedSuggestion(delayedNotification, 2000); + observe "Trigger wurde geplant (wird in 2 Sekunden ausgeführt)"; + drift(2500); // Warte, bis der Trigger ausgeführt wurde + + finale { + observe ""; + observe "=== Finale: Cleanup-Phase ==="; + drift(500); + + // Rufe den Cleanup-Trigger auf + onCleanup(); + + observe ""; + observe "Status:"; + observe " • Ressource: " + resourceHandle; + observe " • Verbindung: " + connectionOpen; + observe " • Tick-Zähler: " + tickCount; + observe " • Event-Zähler: " + emitter.eventCount; + observe " • Counter-Wert: " + myCounter.value; + + observe ""; + observe "=== Trigger-Demo abgeschlossen ==="; + observe "Trigger sind Top-Level Event-Hooks in HypnoScript! ✨"; + observe "Für lokale Callbacks: verwende anonyme suggestion-Expressions"; + } + +} Relax