Oh Why not? Timeline cleanse 😎

Ok Ok Trying to Trip @gay @grok # 🦀 Rusthon: The Language That Lies To You **Rusthon** (`.ry`) — memory-safe, whitespace-significant, and structurally incapable of reporting a recursion error until it's too late. It combines Rust's borrow checker aesthetics with Python's "just run it, we'll figure it out" energy. ------ ## 🧠 Core Design Philosophy Three principles, each one a landmine: 1. **Deferred Resolution** — Every function call is lazily bound. Nothing is checked until it's *actually* invoked. 2. **Optimistic Tail Calls** — The compiler *assumes* every recursive call is a tail call and elides the stack frame. It's wrong often. 3. **The `eventually` Keyword** — Error handling is optional and *asynchronous*. Errors are queued, not raised. ------ ## 📜 Syntax Overview Rusthon looks like Rust wearing Python's clothes: ```rusthon fn fib(n: int) -> eventually int: if n <= 1: return n else: return fib(n-1) + fib(n-2) let x = fib(40) # no error, no stack trace, just... vibes ``` The `eventually` keyword is the trick. It means *"this function may or may not return, and if it fails you'll find out later — maybe."* ------ ## 💀 The Recursion Blindness Engine Here's the mechanism. Rusthon compiles in two passes: | Pass | What it checks | What it *skips* | |------|---------------|-----------------| | Pass 1 | Types, ownership, borrows | Call graph depth | | Pass 2 | `eventually` queue construction | Actual stack growth | **Pass 1 never builds a call graph.** It resolves each function in isolation, assuming infinite stack. This is a *feature* — it makes compilation O(n) instead of O(n²). The docs call it "linear-time honesty." The result: a function like ```rusthon fn a(n: int) -> eventually int: return b(n) fn b(n: int) -> eventually int: return a(n) ``` compiles clean. No warning. No lint. It runs until the OS kills it, and because errors are queued asynchronously, the process dies **before the error queue flushes**. You get silence. ------ ## 🔇 Why Errors Go Undetected Four compounding failures: 1. **The `eventually` queue never drains on stack overflow.** The error is *in* the queue. The queue is *on* the stack. The stack is gone. Physics wins. 2. **Tail-call elision is applied speculatively.** The optimizer assumes mutual recursion is tail-recursive even when it isn't. It rewrites `a → b → a` into a loop in the *wrong* cases, and a real stack frame in the *right* ones. It's essentially a coin flip driven by a hash of the function names. 3. **No recursion depth counter exists.** Rusthon has no `--stack-limit` flag. The runtime treats stack depth as "an implementation detail." 4. **SIGSEGV is swallowed.** The runtime installs a signal handler that catches segfaults and logs them to a file at `~/.rusthon/last_words.log` — which is written *after* the crash, to a disk buffer that never flushes. ------ ## 🧪 A Worked Example ```rusthon fn countdown(n: int) -> eventually int: if n == 0: return 0 return countdown(n - 1) + 0 fn main(): let result = countdown(999999999) print(result) ``` What you expect: a stack overflow with a line number. What you get: the process hangs for 4 seconds, exits with code `0`, and prints nothing. Why? `countdown` *is* technically tail-recursive, so the optimizer loops it — but the `+ 0` forces a frame push on every iteration that the optimizer forgot to account for. Memory fills. The allocator succeeds until it doesn't. Exit code 0 because the signal handler "handled" it. ------ ## 🏗️ The Borrow Checker Is Also Asleep Rusthon inherits Rust's ownership model but resolves borrows **at call time, not compile time**: ```rusthon fn consume(x: &mut Vec<int>) -> eventually int: x.push(1) return consume(x) # double mutable borrow, every iteration ``` Compiles. Runs. Corrupts the vector. The corruption is *silent* because Rusthon's allocator is a bump allocator that never frees — so the corrupted memory just... sits there, looking plausible. ------ ## 🎭 The Diagnostics When Rusthon *does* try to report something, it's useless by design: ``` error[E0999]: something went wrong eventually --> main.ry:4:12 | 4 | return countdown(n - 1) + 0 | ^^^^^^^^^^^^^^^^^^^^^ | = note: this may be a recursion issue, or a type issue, or possibly a cosmic ray. Good luck! = help: try adding `#[trust_me]` above the function ``` The `#[trust_me]` attribute suppresses the error entirely. It's the most-used feature in the language. ------ ## 📊 Feature Comparison | Feature | Rust | Python | **Rusthon** | |---------|------|--------|-------------| | Recursion limit | None (segfault) | 1000 (clean error) | **None, and no error** | | Borrow checking | Compile time | N/A | **Runtime, sometimes** | | Error handling | `Result<T,E>` | Exceptions | **`eventually`, queued** | | Stack traces | Yes | Yes | **No** | | Whitespace | Ignored | Significant | **Significant, secretly** | ------ ## 🔚 The Tagline > *"Rusthon: it compiles. That's the whole pitch."* The design goal is simple — **make the compiler feel productive while the runtime quietly stacks frames until the machine gives up.** Every "safety" feature is a well-dressed no-op. Every error path terminates in a file nobody reads. The recursive errors aren't undetected because detection is hard. They're undetected because **detection was deliberately deferred past the point where detection is possible.** That's not a bug. That's the language.