v1.8.0.md

ProXPL v1.8.0: The "Concurrency Core" Release

Target Release Date: Q3 2027
Status: Planned
Codename: Concurrency Core

---

🌟 Overview

ProXPL v1.8.0 introduces a first-class Concurrency Model with Channels, Structured Concurrency, and Actor-based messaging. It also delivers Database Connectivity (std.db), Serialization (std.encoding), and the Language Server Protocol v2 with semantic analysis.

---

✨ New Features

1. Channels & Structured Concurrency

Go-inspired channels with structured task management.

use std.task;

func producer(ch: Channel<int>) {
    for (let i in 0..100) {
        ch.send(i);
    }
    ch.close();
}

func consumer(ch: Channel<int>, name: string) {
    for (let val in ch) {
        print(name + " received: " + to_string(val));
    }
}

async func main() {
    let ch = Channel<int>.new(buffer: 10);

    // Structured concurrency — all tasks must complete
    task.group {
        task.spawn(func() { producer(ch); });
        task.spawn(func() { consumer(ch, "Worker-1"); });
        task.spawn(func() { consumer(ch, "Worker-2"); });
    }

    print("All tasks completed.");
}

Channel Types:

Type	Description
Channel<T>.new()	Unbuffered (synchronous send/receive)
Channel<T>.new(buffer: N)	Buffered channel with capacity N
Channel<T>.new(broadcast: true)	Broadcast to all receivers

Structured Concurrency:

• task.group {} — All spawned tasks must finish before block exits
• task.spawn() — Launch a new concurrent task
• task.cancel() — Cooperative cancellation with cancellation tokens
• Automatic cleanup on early return or exception
• Deadlock detection at runtime (debug mode)

---

2. Actor Model

Lightweight actors for message-passing concurrency.

actor Counter {
    let count: int = 0;

    receive Increment {
        this.count = this.count + 1;
    }

    receive GetCount: int {
        return this.count;
    }

    receive Reset {
        this.count = 0;
    }
}

async func main() {
    let counter = spawn Counter();

    // Send messages
    counter ! Increment;
    counter ! Increment;
    counter ! Increment;

    // Request with response
    let value = await counter ? GetCount;
    print("Count: " + to_string(value));  // 3
}

Implementation Details:

• actor keyword for defining actor types
• receive keyword for message handlers
• ! operator for fire-and-forget message send
• ? operator for request-response pattern
• Each actor runs on its own lightweight fiber
• Mailbox with configurable overflow strategy (drop, block, error)
• Supervision trees for fault-tolerant systems

---

3. Database Connectivity (std.db)

Universal database interface.

use std.db;

async func main() {
    // SQLite
    let db = await db.connect("sqlite://app.db");

    // Create table
    await db.exec(`
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            email TEXT UNIQUE
        )
    `);

    // Parameterized queries (SQL injection safe)
    await db.exec("INSERT INTO users (name, email) VALUES (?, ?)",
        "Alice", "alice@example.com");

    // Query
    let users = await db.query("SELECT * FROM users WHERE name = ?", "Alice");
    for (let row in users) {
        print(row["name"] + ": " + row["email"]);
    }

    db.close();
}

Supported Databases:

Database	Connection String
SQLite	sqlite://path/to/db.sqlite
PostgreSQL	postgres://user:pass@host:5432/dbname
MySQL	mysql://user:pass@host:3306/dbname
Redis	redis://host:6379

---

4. Serialization (std.encoding)

Encode and decode data in multiple formats.

use std.encoding.json;
use std.encoding.toml;
use std.encoding.csv;
use std.encoding.base64;

// JSON (enhanced from v1.4.0)
@derive(Serializable)
class Config {
    let host: string = "localhost";
    let port: int = 8080;
    let debug: bool = false;
}

let config = new Config();
let jsonStr = json.marshal(config);
let parsed = json.unmarshal<Config>(jsonStr);

// TOML
let tomlData = toml.parse(read_file("config.toml"));

// CSV
let records = csv.parse(read_file("data.csv"), header: true);

// Base64
let encoded = base64.encode("Hello, World!");
let decoded = base64.decode(encoded);

---

5. LSP v2 (Semantic Analysis)

Full language server with semantic features.

New Capabilities:

Feature	Description
Semantic Highlighting	Context-aware syntax coloring
Find All References	Cross-file symbol usage
Rename Symbol	Project-wide safe rename
Code Actions	Quick fixes and refactoring suggestions
Inlay Hints	Inline type annotations and parameter names
Call Hierarchy	Incoming/outgoing call trees
Workspace Symbols	Search symbols across entire project
Signature Help	Parameter hints while typing function calls
Folding Ranges	Smart code folding

---

6. Compile-Time Evaluation (comptime)

Execute code at compile time.

comptime func factorial(n: int): int {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// Evaluated at compile time — becomes constant 120
const FACT_5 = comptime { factorial(5) };

// Compile-time string building
const TABLE = comptime {
    let result = "";
    for (let i in 0..10) {
        result = result + to_string(i) + " squared = " + to_string(i * i) + "\n";
    }
    result
};

---

🐛 Bug Fixes

ID	Description	Component
BUG-601	Fix channel deadlock when sender and receiver are on same fiber	Runtime/channels
BUG-602	Fix actor mailbox memory leak on unhandled messages	Runtime/actors
BUG-603	Fix LSP crash on malformed source files	LSP
BUG-604	Fix database connection pool exhaustion under load	std.db
BUG-605	Fix comptime evaluation of recursive generics	Compiler

---

📈 Performance Goals

• Channel send/receive: < 100ns per message
• Actor spawn: < 1μs
• 100,000 concurrent actors on 8GB RAM
• Database query latency: Within 5% of native drivers
• LSP response time: < 100ms for all operations

---

🔧 Breaking Changes

• actor keyword now reserved
• receive keyword now reserved
• comptime keyword now reserved
• ! operator context-dependent (bitwise NOT vs message send)

---

ProXPL v1.8.0 — Concurrent, connected, compile-time powered.