Whim: Rust-Built Language Adds Native Async, Generics & Pattern Matching to PHP

Background: PHP's Missing Modern Features

Modern web development expects runtime strong typing, generics, pattern matching, and native async concurrency. PHP developers have waited nearly a decade for these capabilities. PHP 8.1 introduced Fibers but no built-in global event loop, leaving async ecosystems fragmented. Generics RFCs stalled over runtime overhead and type erasure concerns, forcing developers to rely on PHPDoc "pseudo-generics" that vanish at runtime. PHP 8's match expression only supports simple value equality, lacking type destructuring, pattern extraction, and guard clauses.

Whim: A Community Solution Built with Rust

Azjezz, author of the Rust-based PHP toolchain Mago, created Whim — a brand-new language written in Rust that retains familiar PHP syntax while reconstructing a modern strong type system and event-driven engine underneath. Its core philosophy: keep PHP's syntactic shell, but fill all missing modern language features at once.

Three Core Features Targeting PHP Pain Points

1. Reified Generics (Runtime Reified Generics)

Traditional PHP uses @template T PHPDoc annotations for static-analysis-only "pseudo-generics"; type information is lost at runtime. Whim implements true reified generics using Rust-style ::<T> (Turbofish) syntax for instantiation. Type information is fully retained at runtime and strictly checked, achieving "static hints, runtime validation."

2. Advanced Pattern Matching

Unlike PHP's native match which only does value equality, Whim's match supports type patterns, variable binding/extraction, and guard conditions. This enables concise destructuring of complex service responses and exception fallback branches, making state-handling logic more compact and readable.

3. Native Single Event Loop + Non-Blocking Concurrency (Future Async Model)

Whim abandons the traditional PHP-FPM synchronous blocking model:

No function coloring: Unlike JavaScript/Python, Whim does not require an async keyword throughout the call chain. Async capability is abstracted as pure Future<T> objects, avoiding async syntax leakage.

Leak-proof lifecycle protection: Every Future submitted to the event loop must be explicitly handled (await, attach then callback, or explicit ignore); otherwise the runtime throws UnhandledAwaitableException, eliminating silent background exception swallowing.

Practical Demonstration: E-Commerce BFF Aggregation

To verify the synergy of generics, pattern matching, and async concurrency, the article provides a complete example ( full_showcase.whim) simulating an order-confirmation page BFF that parallels four backend microservices:

Member Center: query tier & points (~300 ms)

Marketing Platform: compute best coupon (~400 ms)

Risk Control: anti-fraud scoring (~800 ms)

Logistics Warehouse: match nearest warehouse & delivery ETA (~1200 ms)

Code Walkthrough

The example defines a generic ServiceResult<T> class to wrap typed payloads, replacing error-prone associative arrays. A map method enables type-safe transformation (e.g., int → string). A parseServiceStatus function showcases pattern matching on status codes: exact integers (200, 403, 404), type patterns ( int, string), and a catch-all $_.

Four tasks are spawned concurrently via Async\spawn::<ServiceResult<T>>() with Turbofish type arguments. Each task simulates I/O with Async\sleep(Duration) (non-blocking). The main flow continues immediately after dispatch (2 ms). Results are aggregated on-demand with await(), demonstrating completion order: Member (300 ms), Marketing (400 ms), Risk (800 ms), Logistics (1200 ms). The map method converts points to a formatted string. Finally, pattern matching is tested against 403, 504, and a custom degradation string.

Docker Run & Actual Output

Run with:

docker run --rm -v ./whim:/app ghcr.io/carthage-software/whim:latest full_showcase.whim

Actual output shows the event loop dispatching all four tasks within 2 ms, then receiving responses in ascending latency order. Total elapsed time: ~1200.70 ms (dictated by the slowest logistics service). Serial baseline: 300+400+800+1200 = 2700 ms (2.7 s). Speedup: ~2.25×.

Synergistic Value of the Three Features

Generics build type-safe communication pipelines: ServiceResult<int> for risk scores, ServiceResult<string> for coupons, with map for safe conversion — eliminating field-name typos and implicit coercion bugs inherent in associative arrays.

Pattern matching makes state handling explicit and maintainable: Replaces verbose if-else / switch chains with declarative branches covering success, risk intercept, not-found, unknown errors, and degradation.

Async concurrency squeezes I/O wait time: Serial 2.7 s → concurrent 1.2 s (55%+ reduction), yielding multi-fold throughput gains.

Conclusion

PHP's official evolution is slowed by backward-compatibility baggage, but community demand for modern engineering capabilities is unstoppable. Azjezz's Whim — infused with Rust performance and engineering DNA — answers the question: when an ecosystem stagnates, hardcore developers don't just complain; they build the future they want. Does this PHP-syntax new form match what you've been waiting for?