Loxel - A Modern Programming Language

At a glance

Language Features

Expression-Oriented

Everything is an expression. if, match, try, and blocks all return values.

Optional Static Typing

TypeScript-style annotations with full inference. Union, intersection, nullable, and generic types.

Multilingual Keywords

Write in English, Spanish, French, German, Portuguese, Japanese, or Chinese.

Rich Operators

Pipeline |>, Elvis ?:, nullish ??, optional chaining ?., ranges, and more.

Async / Await

First-class concurrency with threads, channels, and async I/O powered by Boost.ASIO.

Pattern Matching

Powerful match expressions with guards, ranges, destructuring, and exhaustive checking.

Code Examples

See Loxel in Action

expressions.lox
// Everything is an expression that returns a value
let max = if (a > b) a else b;

let category = match (age) {
    case in 0..13 => "child",
    case in 13..18 => "teen",
    case _ => "adult"
};

let result = {
    let x = compute();
    let y = process(x);
    x + y  // last expression returned
};

// Ternary and null coalescing
let status = age >= 18 ? "adult" : "minor";
let name = user?.name ?? "Anonymous";

operators.lox
// Pipeline operator: compose left to right
let result = raw_input |> parse |> validate |> transform;

// Elvis operator: default if null
let name = user.name ?: "Anonymous";

// Nullish coalescing
let config = options.timeout ?? 5000;

// Optional chaining
let city = user?.address?.city;
let first = items?.[0];

// Ranges
for (i in 0..10) { print(i); }
let teens = people.filter(p => p.age in 13..20);

// Spread operator
let merged = [...defaults, ...overrides];
let copy = { ...original, status: "updated" };

// Ternary
let label = count == 1 ? "item" : "items";

types_and_pipelines.lox
// Optional static typing with inference
type Handler = (request: Request) => String;
let routes: Map<String, Handler> = {};

// Union types and nullable shorthand
def find(id: Number): User | Error {
    let user: User? = db.get(id);
    return user ?? Error("Not found");
}

// Pipeline operator for functional composition
let response = raw_request
    |> parse
    |> validate
    |> handle;

// Comprehensions
let squares = [x * x for x in 1..11];
let evens = items.filter(x => x % 2 == 0);

concurrency.lox
namespace webserver;
import { parse } from "./http/request";
import { handle } from "./http/router";

// Worker threads pull from a bounded channel
def worker_loop(queue, id: Number): Nil {
    while (true) {
        let client = Channel.receive(queue);
        if (client == nil) { return; }

        let response = TcpSocket.receive_sync(client, 8192)
            |> parse
            |> handle;

        TcpSocket.send_sync(client, response);
        TcpSocket.close(client);
    }
}

// Spawn a pool of workers
def create_pool(queue, count: Number): Array {
    return [Thread.spawn(() => worker_loop(queue, i))
            for i in 0..count];
}

// Main: async accept loop distributes to workers
async def main(): Nil {
    let queue = Channel(100);
    let workers = create_pool(queue, 4);
    let server = TcpServer(8080);

    while (true) {
        let client = await TcpServer.accept(server);
        Channel.send(queue, client);
    }
}

classes.lox
// Classes with self, interfaces, and generics
class Stack<T> {
    def init() {
        self.items: Array<T> = [];
    }

    def push(item: T): Nil {
        self.items.push(item);
    }

    def pop(): T? {
        return if (self.items.length() == 0) nil
               else self.items.pop();
    }

    def peek(): T? => self.items[self.items.length() - 1];

    def size(): Number => self.items.length();
}

// Functional style with arrow functions
let doubled = numbers
    .filter(n => n > 0)
    .map(n => n * 2)
    .reduce(0, (acc, n) => acc + n);

event_hooks.lox
// Event hooks intercept lifecycle events for AOP / metaprogramming

class BankAccount {
    def init(owner: String, balance: Number) {
        self.owner = owner;
        self.balance = balance;
    }

    // Fires before any method call on this object
    @onCall
    def audit(method_name, args) {
        print("[audit] " + self.owner + " -> " + method_name);
    }

    // Fires whenever a property is written
    @onPropertySet
    def validate(prop, value) {
        if (prop == "balance" and value < 0) {
            throw Error("Balance cannot go negative");
        }
    }

    // Fires once, right after init() completes
    @onInstantiate
    def setup() {
        self.tx_count = 0;
    }

    def deposit(amount: Number): Number {
        self.tx_count = self.tx_count + 1;
        self.balance = self.balance + amount;
        return self.balance;
    }
}

let acct = BankAccount("Alice", 100);
acct.deposit(50);  // prints: [audit] Alice -> deposit
                   // balance becomes 150

i18n_and_emoji.lox
// Loxel keywords work in 7 languages
// English
def greet(name: String) => `Hello, ${name}`;

// Spanish
funcion saludar(nombre: Cadena) => `Hola, ${nombre}`;

// Chinese Simplified
函数 问候(名字: 字符串) => `你好, ${名字}`;

// All three produce the same result
let greeting = greet("world");
let resultado = saludar("mundo");
let 消息 = 问候("世界");

// Emoji identifiers are valid too 🚀 💯 ✨
let 🚀launch = true;
let 💯score = 100;
let ✨sparkles = "amazing";

Internationalization

Write Code in Your Language

Loxel supports multilingual keywords and type names.

English

def class String

Español

funcion clase Cadena

Français

fonction classe Chaîne

Deutsch

funktion klasse Zeichenkette

Português

funcao classe Cadeia

日本語

関数 クラス 文字列

中文

函数 类 字符串

Live Server

This Page Is Served by Loxel

Workers

Queue Capacity

100

Request

GET /

Protocol

HTTP/1.1

/health /echo