Reference on Zenth Programming Language

Variables

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has three ways to declare variables: let, var, and const. All declarations use = for assignment – there is no := operator.

#Immutable Variables with `let`

let declares an immutable binding. Once assigned, its value cannot change:

let name = "Zenth";
let year = 2026;
let pi = 3.14159;
let active = true;

Attempting to reassign a let variable is a compile-time error:

let x = 5;
x = 10; // error: cannot assign to immutable variable 'x'

#Mutable Variables with `var`

var declares a mutable binding that can be reassigned:

Types

Mon, 01 Jan 0001 00:00:00 +0000

Zenth is strongly typed with type inference for local variables. Function signatures always require explicit types.

#Integer Types

Zenth has a single integer type: Int (64-bit signed).

let x = 42; // Int (inferred)
let big: Int = 999;

Integer literals can use underscores for readability:

let million = 1_000_000;

#Built-in Integer Constants

Zenth provides built-in constants for the integer range limits:

Constant	Value	Description
`INT_MAX`	9223372036854775807	Maximum `Int` value (2^63-1)
`INT_MIN`	-9223372036854775808	Minimum `Int` value (-2^63)

These are true constants and cannot be reassigned:

Functions

Mon, 01 Jan 0001 00:00:00 +0000

Functions are declared with the fn keyword. Every program needs a main function as its entry point.

#Declaring Functions

fn greet(name: Str) {
 Println("Hello, {name}!");
}

Parameters require explicit type annotations using the name: Type syntax.

#Return Types

Specify a return type with ->:

fn add(a: Int, b: Int) -> Int {
 return a + b;
}

Functions without a -> return type return nothing (void).

#Calling Functions

fn main() {
 greet("World");
 let result = add(3, 4);
 Println(result); // 7
}

#Multiple Parameters

fn clamp(value: Int, low: Int, high: Int) -> Int {
 if value < low {
 return low;
 }
 if value > high {
 return high;
 }
 return value;
}

#Multi-Return Functions

Functions can return multiple values using a parenthesized return type. The caller unpacks the result with tuple destructuring:

Strings

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has two kinds of string literals: double-quoted strings with interpolation, and single-quoted raw strings.

#Double-Quoted Strings

Double-quoted strings ("...") support interpolation with {expression}:

let name = "World";
Println("Hello, {name}!"); // Hello, World!

Any expression can go inside the braces – variables, arithmetic, method calls:

let a = 3;
let b = 4;
Println("{a} + {b} = {a + b}"); // 3 + 4 = 7

Values are automatically converted to strings, so you don’t need to call Str() inside interpolation:

Control Flow

Mon, 01 Jan 0001 00:00:00 +0000

#If / Else

if x > 10 {
 Println("big");
} else if x > 5 {
 Println("medium");
} else {
 Println("small");
}

Conditions must be Bool – there is no truthy/falsy coercion. Parentheses around the condition are not required.

#For Loops

for is the only loop keyword in Zenth. It supports five styles.

#C-Style For

The classic three-part loop with init, condition, and post:

for var i = 0; i < 10; i++ {
 Println(i);
}

The init clause can declare a variable with var or let:

Enums

Mon, 01 Jan 0001 00:00:00 +0000

Enums define a type with a fixed set of named variants. Each variant is backed by a string value — by default the variant name itself.

#Declaring Enums

enum Color {
 Red;
 Green;
 Blue;
}

Without explicit values, each variant’s string value is its name: "Red", "Green", "Blue".

#Explicit String Values

You can assign explicit string values to variants:

enum HexColor {
 Red = "#FF0000";
 Green = "#00FF00";
 Blue = "#0000FF";
}

enum Stoplight {
 Red = "red";
 Yellow = "yellow";
 Green = "green";
}

#Using Enums

Access variants with EnumName.Variant syntax:

Objects

Mon, 01 Jan 0001 00:00:00 +0000

Objects are user-defined types with named fields. Methods are defined inside the object body using self to access fields.

#Declaring an Object

obj Point {
 x: Float;
 y: Float;
}

Fields are declared with name: Type; syntax.

#Default Field Values

Fields can have default values. If a default is provided, the field becomes optional in the constructor:

obj Account {
 balance: Int = 0;
 interest: Float = 2.5;
}

#Creating Instances

Use constructor syntax with named arguments Name(field=value):

Arrays

Mon, 01 Jan 0001 00:00:00 +0000

Arrays are dynamically-sized sequences of elements, all of the same type.

#Creating Arrays

Use bracket syntax for array literals:

let numbers = [1, 2, 3, 4, 5];
let names = ["Alice", "Bob", "Charlie"];

With an explicit type annotation:

let scores: Array(Int) = [100, 95, 87];

An empty slice can use a type annotation:

var points: Array(Point) = [];
points.add(Point(x=1, y=2));

Use .repeat(n) to create an array by repeating elements:

var zeros = [0].repeat(10); // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
let dashes = ["-"].repeat(5); // ["-", "-", "-", "-", "-"]
let pattern = [1, 2].repeat(6); // [1, 2, 1, 2, 1, 2]

When the source array has multiple elements, they tile to fill the requested count.

Tuples

Mon, 01 Jan 0001 00:00:00 +0000

Tuples are fixed-size ordered values that can hold mixed types. They come in two forms: positional and named.

#Positional Tuples

Use Tuple(...) to create a tuple with values accessed by numeric index:

let t = Tuple("hello", 42);
Println(t.0); // "hello"
Println(t.1); // "42"

With a type annotation:

let pair: Tuple(Str,Int) = Tuple("age", 30);

#Named Tuples

Named tuples add field names so you can access elements by name. Use = for values and : for types:

Hashmaps

Mon, 01 Jan 0001 00:00:00 +0000

Hashmaps are unordered collections of key-value pairs.

#Creating Hashmaps

You can create a hashmap using the Hashmap(KeyType, ValueType) built-in:

var scores = Hashmap(Str,Int);

#Assigning and Accessing

Use bracket syntax [key] to assign and access values:

scores["Alice"] = 100;
scores["Bob"] = 95;

let aliceScore = scores["Alice"];
Println(aliceScore);

#Hashmap Length

Use Len() to get the number of key-value pairs in the hashmap:

Println(Len(scores));

#Default Values

You can provide a default value for missing keys using the default named argument:

Sets

Mon, 01 Jan 0001 00:00:00 +0000

Sets are unordered collections of unique values.

#Creating Sets

Create an empty set with Set(Type):

var visited = Set(Str);
visited.add("start");
visited.add("middle");

You can also convert an array into a set with Set(items):

let letters = ["a", "b", "a"];
let unique = Set(letters);
Println(Len(unique)); // 2

#Core Operations

Use .add(value) to insert an item, .exists(value) to test membership, and .remove(value) to delete an item:

var nums = Set(Int);
nums.add(1);
nums.add(2);
nums.add(2); // duplicate, ignored

Println(nums.exists(1)); // true
nums.remove(1);
Println(Len(nums)); // 1

Sets also expose .length() when you prefer method syntax:

Dates

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has a built-in Date type for working with calendar dates. Dates are created using static constructors and support formatting, addition, and subtraction.

#Creating Dates

#Today’s date

let d = Date.today();

Returns a Date object representing the current date (time portion is midnight UTC).

#From a string

let epoch = Date.from("1970-01-01");

Parses a date string using the default format %Y-%m-%d (year-month-day).

#From a string with custom format

let jan13 = Date.from("01/13/2007", "%m/%d/%Y");

The second argument is a Python-style format string. Available format specifiers:

Files

Mon, 01 Jan 0001 00:00:00 +0000

The File() built-in creates a file object for reading and writing files and inspecting file paths. File objects are value types – there are no open handles and nothing to close.

#Creating a File Object

let f = File("/path/to/data.txt");

#Methods

#exists

Returns true if the file exists on disk:

let f = File("config.txt");
if f.exists() {
 Println("found it");
}

#read

Returns the full file contents as a string. Exits with an error if the file cannot be read:

Imports

Mon, 01 Jan 0001 00:00:00 +0000

Zenth provides access to standard library functionality through imports. Under the hood, these map to Go standard library packages.

#Basic Import

import "fmt";

#Aliased Import

Use as to give an import a shorter name:

import "math" as m;

Then call functions through the alias:

let root = m.sqrt(16.0);

#Available Modules

Zenth module	Maps to	Common functions
`fmt`	Go `fmt`	`println`, `printf`, `sprintf`
`math`	Go `math`	`sqrt`, `abs`, `pow`, `min`, `max`
`os`	Go `os`	`exit`, `args`
`strings` or `Str`	Go `strings`	`split`, `join`, `contains`, `replace`, `trim`

#Calling Module Functions

import "math";

fn main() {
 let x = math.sqrt(144.0);
 Println(x); // 12

 let y = math.pow(2.0, 10.0);
 Println(y); // 1024
}

#Example with String Operations

import "strings";

fn main() {
 let csv = "apple,banana,cherry";
 let parts = strings.split(csv, ",");
 for part in parts {
 Println(part);
 }
}

#External Go Package Imports

Use import_go to import any Go package — including third-party libraries. The Zenth toolchain automatically fetches the package using go get before compiling.

Modules

Mon, 01 Jan 0001 00:00:00 +0000

Zenth supports splitting programs across multiple files using local modules. A module is simply a .zn File (or a directory of .zn files) that you import into your program.

#Importing a Local Module

Use a path starting with ./ or ../ to import a local module:

import "./utils";
import "./math/geometry";
import "../shared/helpers";

The module name is derived from the filename stem (the last path component without .zn). Use as to give it a custom alias:

Testing

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has a built-in test runner that discovers and runs test functions. Test files live in a tests/ directory and use the _test.zn suffix.

#Writing Tests

Create a file ending with _test.zn in a tests/ directory. Define test functions that start with test_:

// tests/math_test.zn

fn test_addition() {
 AssertEq(2 + 3, 5);
}

fn test_negative_numbers() {
 AssertEq(-3 + 3, 0);
 Assert(-1 < 0);
}

Test files do not need a fn main() – the test runner generates one automatically.

Reference on Zenth Programming Language

Variables

#Immutable Variables with let

#Mutable Variables with var

Types

#Integer Types

#Built-in Integer Constants

Functions

#Declaring Functions

#Return Types

#Calling Functions

#Multiple Parameters

#Multi-Return Functions

Strings

#Double-Quoted Strings

Control Flow

#If / Else

#For Loops

#C-Style For

Enums

#Declaring Enums

#Explicit String Values

#Using Enums

Objects

#Declaring an Object

#Default Field Values

#Creating Instances

Arrays

#Creating Arrays

Tuples

#Positional Tuples

#Named Tuples

Hashmaps

#Creating Hashmaps

#Assigning and Accessing

#Hashmap Length

#Default Values

Sets

#Creating Sets

#Core Operations

Dates

#Creating Dates

#Today’s date

#From a string

#From a string with custom format

Files

#Creating a File Object

#Methods

#exists

#read

Imports

#Basic Import

#Aliased Import

#Available Modules

#Calling Module Functions

#Example with String Operations

#External Go Package Imports

Modules

#Importing a Local Module

Testing

#Writing Tests

#Immutable Variables with `let`

#Mutable Variables with `var`