## Zen Programming Language Features The Zen programming language introduces a fresh paradigm with its "zero keywords" philosophy, leveraging pattern matching, Uniform Function Call (UFC), and powerful metaprogramming for expressive and concise code. The [`LANGUAGE_SPEC.zen`](./LANGUAGE_SPEC.zen) serves as the definitive source of truth for the language's design. This page provides an overview of Zen's core features through illustrative code examples, directly sourced from the project's README. ## Variables - Six Forms, No Keywords Zen offers six distinct ways to declare variables, emphasizing immutability by default and providing clear syntax for mutability, all without relying on traditional keywords. ```zen x: i32 // Forward declaration (immutable) x = 10 // Assignment y = 10 // Immutable assignment (type inferred) z: i32 = 20 // Immutable with type w:: i32 // Mutable forward declaration w = 20 // Assignment v ::= 30 // Mutable assignment (type inferred) u:: i32 = 40 // Mutable with type ``` - `x: i32`: Declares `x` as an `i32` but doesn't initialize it immediately; `x` is immutable by default. - `x = 10`: Assigns a value to a previously declared variable or implicitly declares an immutable variable if not already existing. - `y = 10`: Infers the type of `y` as `i32` and makes it immutable. - `z: i32 = 20`: Explicitly declares `z` as an `i32` and initializes it immutably. - `w:: i32`: Declares `w` as a mutable `i32` without immediate initialization. - `w = 20`: Assigns a value to the mutable variable `w`. - `v ::= 30`: Infers the type of `v` as `i32` and makes it mutable. - `u:: i32 = 40`: Explicitly declares `u` as a mutable `i32` and initializes it. ## Pattern Matching - Replaces All Conditionals Zen replaces all traditional conditional keywords like `if/else`, `while`, `for`, and `match` with a powerful pattern matching operator: `?`. ```zen // Boolean patterns (lines 352-361) is_ready = true is_ready ? { io.println("Starting game!") } has_data = false has_data ? | true { process_data() } | false { io.println("Waiting for data...") } // Enum patterns (lines 325-335) entity ? | Player { io.println("Player health: ${entity.get_health()}") } | Enemy { io.println("Enemy health: ${entity.get_health()}") } ``` - **Boolean Patterns**: For simple boolean checks, `condition ? { ... }` executes the block if `condition` is `true`. For `if/else` logic, multiple arms can be used: `condition ? | true { ... } | false { ... }`. - **Enum Patterns**: The `?` operator is used with enum variants to execute different code blocks based on the variant of the `entity` variable. This provides a type-safe way to handle different data states. ## Structs and Enums Zen provides `structs` for composite data types and `enums` for sum types, without requiring explicit keywords for their definition, using `:` for type definition. ```zen // Struct definition (lines 117-120) Point: { x:: f64, // Mutable field y:: f64 = 0 // With default value } // Enum (sum type) definition (line 166) Shape: Circle, Rectangle // Enum with variants for overloading (line 172) GameEntity: Player, Enemy, Powerup ``` - **Struct Definition**: `Point: { ... }` defines a struct named `Point`. Fields can be mutable (`x:: f64`) or have default values (`y:: f64 = 0`). - **Enum Definition**: `Shape: Circle, Rectangle` defines an enum where `Circle` and `Rectangle` are unit variants. Enums can also serve as type discriminators for UFC, as seen with `GameEntity`. ## Traits - Behavioral Types Traits in Zen define shared behavior across different types, similar to interfaces or type classes in other languages. They are defined using a declarative syntax and implemented using `.implements()`. ```zen // Trait definition (lines 123-127) Geometric: { area: (self) f64, perimeter: (self) f64, } // Implementation (lines 136-143) Circle.implements(Geometric, { area = (self) f64 { return math.pi * self.radius * self.radius }, perimeter = (self) f64 { return 2.0 * math.pi * self.radius }, }) // Requirement (line 168) Shape.requires(Geometric) // All Shape variants must implement Geometric ``` - **Trait Definition**: `Geometric: { ... }` defines a trait with method signatures (`area` and `perimeter`). - **Implementation**: `Circle.implements(Geometric, { ... })` provides concrete implementations of the `Geometric` trait for the `Circle` type. - **Requirement**: `Shape.requires(Geometric)` states that all variants of the `Shape` enum must implement the `Geometric` trait, enforcing behavioral contracts. ## UFC (Uniform Function Call) UFC allows any function to be called as a method, facilitating a flexible and extensible object-oriented style. It also enables function overloading based on enum variants. ```zen // UFC overloading based on enum variants (lines 174-181) get_health = (e: GameEntity.Player) u32 { return 100 } get_health = (e: GameEntity.Enemy) u32 { return 50 } get_health = (e: GameEntity.Powerup) u32 { return 0 } // Can call as: player.get_health() // UFC style get_health(player) // Traditional style ``` - **Overloading**: The `get_health` function is overloaded to provide different implementations based on the specific `GameEntity` variant it receives. - **Call Styles**: Functions can be called in either a method-like UFC style (`player.get_health()`) or a traditional function call style (`get_health(player)`), promoting flexibility. ## Option and Result - No Null Zen eliminates `null` or `nil` by providing `Option` for potentially absent values and `Result` for fallible operations, encouraging explicit error handling. ```zen // Option type (line 110) Option: Some: T, None // Result type (line 113) Result: Ok: T, Err: E // Option handling (lines 462-473) maybe_radius: Option = Some(5.5) maybe_radius ? | Some(r) { circle = Circle { center: Point { x: 100, y: 100 }, radius: r } io.println("Created circle with area: ${circle.area()}") } | None { io.println("No radius provided") } ``` - **Type Definitions**: `Option` is an enum with `Some(T)` (value present) and `None` (value absent). `Result` is an enum with `Ok(T)` (success with value) and `Err(E)` (failure with error). - **Handling**: The `?` operator is used to elegantly destructure `Option` values, executing different branches based on whether a value is `Some` or `None`. ## Error Propagation with .raise() Error handling is explicit in Zen, primarily through the `Result` type and a `.raise()` method for concise error propagation, avoiding exceptions. ```zen // Error propagation (lines 206-211) load_config = (path: string) Result { file = File.open(path).raise() // If Err, returns early contents = file.read_all().raise() // Propagates errors config = json.parse(contents).raise() return Ok(config) } ``` - The `.raise()` method, when called on a `Result`, will either extract the `T` value if it's `Ok`, or immediately return the `E` value if it's `Err`, propagating the error up the call stack. This eliminates boilerplate `if let` checks for every fallible operation. ## Loops and Ranges Zen offers flexible looping constructs, including infinite loops, and range expressions for iteration, all integrated with the UFC style. ```zen // Range iteration (lines 432-434) (0..10).loop((i) { io.println("Count: ${i}") }) // Step ranges (lines 437-439) (0..100).step(10).loop((i) { io.println("Step: ${i}") // 0, 10, 20, ... }) // Collection iteration with UFC (lines 442-445) shapes.loop((shape) { total_area = total_area + shape.area() }) // Infinite loop (lines 453-459) counter ::= 0 loop(() { counter = counter + 1 counter > 10 ? | true { break } | false { continue } }) ``` - **Range Iteration**: `(0..10).loop((i) { ... })` iterates over a numerical range, with `i` taking each value. `(0..100).step(10)` allows iterating with a custom step size. - **Collection Iteration**: Collections can also be iterated using the `.loop()` method, enabling concise processing of elements (`shapes.loop((shape) { ... })`). - **Infinite Loops**: `loop(() { ... })` creates an infinite loop, with `break` and `continue` statements controlling its flow. The `?` operator handles conditional breaking. ## Allocator-Driven Concurrency Zen distinguishes between synchronous and asynchronous operations not by function coloring, but by the allocator used, providing a unified function signature. ```zen // Multisync function - sync or async based on allocator! (lines 215-224) fetch_game_data = (url: string, alloc: Allocator) Result { client = HttpClient(alloc) // Behavior determined by allocator @this.defer(client.deinit()) // This blocks or doesn't based on allocator! response = client.get(url) response ? | Ok(data) { return Ok(parse_data(data)) } | Err(e) { return Err(e) } } // Usage (lines 308-314) sync_alloc = GPA.init() // Sync allocator - everything blocks async_alloc = AsyncPool.init() // Async allocator - non-blocking ``` - **Unified Functions**: A single function like `fetch_game_data` can behave synchronously or asynchronously depending on the `Allocator` passed to it. This avoids function coloring, where functions must explicitly mark themselves as `async` or `await`. - **Allocator Choice**: The `GPA.init()` provides a synchronous allocator, while `AsyncPool.init()` provides an asynchronous one, driving the concurrency model. ## Pointers - Explicit, No Symbols Zen features explicit pointer types instead of relying on `*` or `&` symbols, making pointer usage clearer and type-safe. ```zen // Explicit pointer types (lines 364-371) circle = Circle { center: Point { x: 100, y: 100 }, radius: 50 } circle_ptr: Ptr = circle.ref() // Immutable pointer circle_mut: MutPtr = circle.mut_ref() // Mutable pointer io.println("Circle area: ${circle_ptr.val.area()}") // .val to dereference circle_mut.val.radius = 75 // Modify through pointer io.println("Address: ${circle_ptr.addr}") // Access address ``` - **Types**: `Ptr`, `MutPtr`, and `RawPtr` explicitly denote immutable, mutable, and raw (unsafe) pointers. - **Operations**: `.ref()` creates an immutable pointer, `.mut_ref()` creates a mutable one. Dereferencing is done via `.val`, and the memory address can be accessed via `.addr`. ## Metaprogramming and Reflection Zen provides powerful compile-time metaprogramming with full AST access, allowing code generation and transformation, along with runtime reflection capabilities. ```zen // Runtime reflection (lines 244-272) inspect_type = (T: type) void { ast = reflect.ast(T) ast.kind ? | Struct(s) { io.println("Struct: ${s.name}") s.fields.loop((f) { io.println(" Field: ${f.name}: ${f.type}") }) } | Enum(e) { io.println("Enum: ${e.name}") e.variants.loop((v) { io.println(" Variant: ${v.name}") }) } } // Compile-time AST modification (lines 275-281) @meta.comptime((){ original = reflect.ast(parse_radius) new_body = original.body.prepend( AST.Call("io.println", ["Parsing radius from: ${s}"]) ) meta.replace(parse_radius, original.with_body(new_body)) }) ``` - **Runtime Reflection**: The `reflect.ast(T)` function allows runtime inspection of a type's Abstract Syntax Tree (AST), enabling dynamic type introspection and manipulation. - **Compile-time AST Modification**: The `@meta.comptime` block executes code at compile-time, allowing programmatic access to and modification of the AST. This example prepends a `println` call to a function's body. ## Concurrency Primitives Zen provides first-class support for concurrency via actors, channels, mutexes, and atomics, designed for robust and efficient parallel programming. ```zen // Actors for lazy/streaming iteration (lines 228-240) create_fibonacci = () Actor { outer = 100 // Captured automatically return Actor((receiver) { a ::= 0 b ::= 1 loop(() { receiver.send(a + outer) temp = a + b a = b b = temp }) }) } // Channels (lines 397-412) message_chan = Channel(10) // Buffered channel @this.defer(message_chan.close()) // Mutex (lines 415-423) counter_mutex = Mutex(0) counter_mutex.lock() ? | Ok(val) { val = val + 1 counter_mutex.unlock() } | Err(e) { io.println("Lock failed: ${e}") } // Atomics (lines 426-429) atomic_counter = AtomicU32(0) atomic_counter.fetch_add(1) ``` - **Actors**: `Actor((receiver) { ... })` defines an actor that can send messages to a `receiver`, useful for streaming data and lazy evaluation. - **Channels**: `Channel(10)` creates a buffered channel for message passing between concurrent tasks. - **Mutex**: `Mutex(0)` provides mutual exclusion for shared data, preventing race conditions. The `?` operator is used for handling lock acquisition results. - **Atomics**: `AtomicU32(0)` offers atomic operations for lock-free concurrency on primitive types. ## Mixed Type Vectors Zen's `DynVec` allows storing elements of different types (variants of an enum) within a single vector, enabling flexible data structures. ```zen // DynVec can hold multiple variant types! (lines 316-335) entities = DynVec(sync_alloc) entities.push(GameEntity.Player) entities.push(GameEntity.Enemy) // Loop over mixed types with pattern matching entities.loop((entity) { entity ? | Player { io.println("Player health: ${entity.get_health()}") } | Enemy { io.println("Enemy health: ${entity.get_health()}") } }) ``` - **Flexible Storage**: `DynVec` demonstrates a dynamic vector capable of holding multiple enum variants, offering a flexible way to manage heterogeneous collections. - **Pattern Matching**: Iterating over a `DynVec` allows using pattern matching to process each element according to its specific type variant. ## Module System Zen's module system supports importing and exporting symbols, enabling code organization and reuse. ```zen // Imports (lines 92-106) { io, maths } = @std { String, StringBuilder } = @std { Vec, DynVec } = @std // Module exports (lines 492-502) module.exports = { Shape: Shape, Circle: Circle, Rectangle: Rectangle, get_health: get_health, } // Imports in other files Circle2D = module.import("shapes2d").Circle shapes = module.import("shapes2d") ``` - **Imports**: Destructuring assignment (`{ io, maths } = @std`) is used to import specific symbols from modules within the standard library (`@std`). - **Exports**: `module.exports = { ... }` explicitly declares which symbols (types, functions, etc.) a module makes available to other modules. - **External Imports**: `module.import("shapes2d").Circle` shows how to import specific symbols from user-defined modules, demonstrating a clean and explicit module dependency management.

Language Features by Example

Page Viewers

Guest Views