Zenith v2.0.0

Example Usage

fn greet(name: str) {
    pnt "Hello, {name}!"
}

fn add(a: int, b: int) -> int {
    ret a + b
}

// Function calls
greet("World")
let result = add(5, 3)

Functions can have parameters with type annotations and return values. The ret keyword is used to return values.

Example Usage

let name = "Zenith"
let version = 2.0
let is_stable = true
let pi: flt = 3.14159

// These assignments would cause errors:
// name = "Other"  // Error: cannot reassign immutable variable
// version = 3.0   // Error: cannot reassign immutable variable

Variables declared with let cannot be reassigned after initialization. Type annotations are optional when the type can be inferred.

Example Usage

mut counter = 0
mut message = "Starting"

// These are allowed:
counter = 1
counter = counter + 1
message = "Running"
message = message + "..."

pnt "{message}: {counter}"

Variables declared with mut can be reassigned after initialization. This is useful for counters, accumulators, and state variables.

Example Usage

fn square(x: int) -> int {
    ret x * x
}

fn get_message() -> str {
    ret "Hello, Zenith!"
}

fn process_data(data: [int]) -> int {
    mut sum = 0
    for item in data {
        sum = sum + item
    }
    ret sum  // Return the final sum
}

The ret keyword exits the function and returns the specified value. Functions with return types must return a value using ret.

Example Usage

pnt "Hello, World!"

let name = "Zenith"
let version = 2.0
pnt "Welcome to {name} v{version}"

mut counter = 0
whl counter < 3 {
    pnt "Count: {counter}"
    counter = counter + 1
}

The pnt keyword prints values to standard output. String interpolation is supported using {variable} syntax.

Example Usage

let temperature = 25

if temperature > 30 {
    pnt "It's hot!"
} else if temperature > 20 {
    pnt "It's warm."
} else {
    pnt "It's cool."
}

let is_raining = true
if is_raining {
    pnt "Take an umbrella."
}

The if keyword executes code based on boolean conditions. It can be combined with else if and else.

Example Usage

const PI = 3.14159
const MAX_USERS = 1000
const APP_NAME = "ZenithApp"

// Constants cannot be changed
// PI = 3.14  // This would cause a compile error

fn calculate_circumference(radius: flt) -> flt {
    ret 2.0 * PI * radius
}

pnt "Welcome to {APP_NAME}"
pnt "Max users allowed: {MAX_USERS}"

The const keyword declares values that are known at compile time and cannot be changed during execution.

Example Usage

fn counter() -> int {
    static mut count = 0
    count = count + 1
    ret count
}

pnt counter()  // 1
pnt counter()  // 2
pnt counter()  // 3

The static keyword creates variables that persist across function calls, maintaining their values between invocations.

Example Usage

import std::collections::HashMap
import std::fmt::Display

// Import with alias
import std::collections::HashMap as Map

// Import multiple items
import std::fs::{read_file, write_file}

// Use imported items
let mut map = HashMap::new()
map.insert("key", "value")

The import keyword makes items from other modules available in the current scope, similar to use.

Example Usage

module math {
    fn add(a: int, b: int) -> int {
        ret a + b
    }
    
    fn multiply(a: int, b: int) -> int {
        ret a * b
    }
}

module ui {
    fn render_button(label: str) {
        pnt "[Button: {label}]"
    }
}

// Use items from modules
let sum = math::add(5, 3)
let product = math::multiply(4, 7)
ui::render_button("Submit")

The module keyword creates modules to group related functions, types, and other items, similar to mod.

Example Usage

fn divide(a: int, b: int) -> Result {
    if b == 0 {
        ret Err("Division by zero")
    }
    ret Ok(a / b)
}

fn main() {
    let result = try divide(10, 2) {
        Ok(value) => value,
        Err(error) => {
            pnt "Error: {error}"
            ret 0
        }
    }
    
    pnt "Result: {result}"
}

The try keyword provides a way to handle errors gracefully without crashing the program.

Example Usage

fn risky_operation() -> Result {
    // Simulate an operation that might fail
    ret Err("Something went wrong")
}

fn main() {
    let result = try risky_operation() catch error {
        pnt "Caught error: {error}"
        "Default value"
    }
    
    pnt "Result: {result}"
}

The catch keyword handles exceptions thrown by code in a try block.

Example Usage

fn process_file(filename: str) -> Result {
    pnt "Opening file: {filename}"
    
    try {
        // File processing logic
        if filename == "missing.txt" {
            throw "File not found"
        }
        ret "File processed successfully"
    } catch error {
        ret "Error: {error}"
    } finally {
        pnt "Closing file connection"
    }
}

process_file("data.txt")
process_file("missing.txt")

The finally keyword ensures cleanup code runs whether an exception occurs or not.

Example Usage

fn validate_age(age: int) -> Result<(), str> {
    if age < 0 {
        throw "Age cannot be negative"
    }
    if age > 150 {
        throw "Age seems unrealistic"
    }
    ret Ok(())
}

fn main() {
    try {
        validate_age(-5)
    } catch error {
        pnt "Validation error: {error}"
    }
}

The throw keyword raises exceptions that can be caught and handled by catch blocks.

Example Usage

fn fibonacci_generator() -> Generator {
    mut a = 0
    mut b = 1
    
    loop {
        yield a
        let temp = a
        a = b
        b = temp + b
    }
}

fn main() {
    let fib = fibonacci_generator()
    
    // Get first 10 Fibonacci numbers
    for i in 0..10 {
        let value = fib.next()
        pnt "Fib[{i}]: {value}"
    }
}

The yield keyword allows functions to produce a sequence of values lazily, one at a time.

Example Usage

macro debug_print(variable: expr) {
    pnt "[DEBUG] {stringify(variable)} = {variable}"
}

macro create_getter_setter(field_name: ident, field_type: ty) {
    fn get_{field_name}(self) -> field_type {
        ret self.{field_name}
    }
    
    fn set_{field_name}(mut self, value: field_type) {
        self.{field_name} = value
    }
}

struct Person {
    name: str,
    age: int,
    
    create_getter_setter(name, str)
    create_getter_setter(age, int)
}

fn main() {
    let person = Person(name="Alice", age=30)
    debug_print(person.name)
    debug_print(person.age)
}

The macro keyword enables metaprogramming by generating code at compile time.

Example Usage

let number = 42
let text = "Hello"
let is_valid = true
let list = [1, 2, 3]

pnt typeof number     // int
pnt typeof text       // str
pnt typeof is_valid   // bool
pnt typeof list       // [int]

The typeof keyword returns a string representation of a value's type.

Example Usage

struct Dog {
    name: str,
    breed: str,
}

struct Cat {
    name: str,
    color: str,
}

let animal1 = Dog(name="Buddy", breed="Golden Retriever")
let animal2 = Cat(name="Whiskers", color="Orange")

if animal1 instanceof Dog {
    pnt "{animal1.name} is a dog"
}

if animal2 instanceof Cat {
    pnt "{animal2.name} is a cat"
}

The instanceof keyword checks if a value is an instance of a particular type or struct.

Example Usage

let value: any = "123"
let number = value as int
let text = number as str

pnt typeof value   // str
pnt typeof number  // int
pnt typeof text    // str

// Casting in expressions
let result = ("42" as int) + 8
pnt result  // 50

The as keyword converts values between compatible types.

Example Usage

fn process_value(value: any) {
    match value {
        x is int => pnt "Integer: {x}",
        x is str => pnt "String: {x}",
        x is bool => pnt "Boolean: {x}",
        x is [int] => pnt "Integer array with {x.length} elements",
        _ => pnt "Unknown type"
    }
}

process_value(42)
process_value("Hello")
process_value(true)
process_value([1, 2, 3])

The is keyword checks and extracts values of specific types in pattern matching.

Example Usage

// Iteration
for i in 0..5 {
    pnt i
}

// Membership check
let list = [1, 2, 3]
if 2 in list {
    pnt "Found 2"
}

The in keyword is versatile, used in both for loops and boolean expressions.

Example Usage

let is_ready = false

if not is_ready {
    pnt "Not ready yet"
}

let x = 10
if not (x > 20) {
    pnt "x is not greater than 20"
}

The not keyword inverts a boolean value.

Example Usage

let has_ticket = true
let has_id = true

if has_ticket and has_id {
    pnt "Access granted"
}

let age = 25
if age >= 18 and age <= 65 {
    pnt "Eligible age"
}

The and keyword returns true only if both operands are true.

Example Usage

let x = 2
match x {
    1 => pnt "One",
    2 => pnt "Two",
    3..5 => pnt "Three to Five",
    _ => pnt "Other"
}

Example Usage

mut count = 0
loop {
    count += 1
    if count > 5 { break }
    pnt count
}

Example Usage

for i in 0..10 {
    if i == 5 { break }
    pnt i
}

Example Usage

for i in 0..5 {
    if i == 2 { continue }
    pnt i
}

Example Usage

use std::io
use std::collections::HashMap

let map = HashMap::new()

Example Usage

mod utilities {
    fn helper() { pnt "Helping" }
}

Example Usage

mod my_mod {
    pub fn public_fn() { }
    fn private_fn() { }
}

Example Usage

struct Counter {
    count: int
    
    fn increment(mut self) {
        self.count += 1
    }
}

Example Usage

mod parent {
    fn hello() { }
    
    mod child {
        fn call_parent() {
            super::hello()
        }
    }
}

Example Usage

component Button {
    state {
        is_hovered: bool
    }

    render {
        Container {
            Text("Click Me")
        }
    }
}

Components are the building blocks of Zenith UI applications.

Example Usage

state {
    count: int,
    username: str
}

State variables are reactive and trigger re-renders when changed.

Example Usage

render {
    VStack {
        Text("Hello")
        Button("Click")
    }
}

The render block returns the component's UI hierarchy.