The Language Built for Precision

# primitive types
int    x = 42
double pi = 3.14
long   timestamp = 326293729283L
byte   b = 255B
string name = "zen"
bool   flag = true

# type inference
auto result = x * 2

# constants
const int MAX = 1000

# reactive (re-evaluates on change)
reactive string msg = `val: ${x}`

# typed function
fn add(int a, int b) int {
  return a + b
}

# auto return type
fn greet(string name) auto {
  return `Hello, ${name}!`
}

# rest parameters
fn sum(int vals...) List<int> {
  return vals
}

# normal loop
loop (int i = 0, i < 10, i++) {
  screen(i)
}

# while
while (x > 0) { x-- }

# do while
do {
  screen(x)
} while (x > 0)

# iterate List, fixed size arrays or rest params
loop (n of nums) {
  screen(n)
}

# typed list
List<int> nums = [1, 2, 3]
nums.push(4)
int len = nums.length

# map
Map person = {
  name: "Jishith",
  age: 25
}

bool has = person.has("name")
person.remove("age")

struct Point {
  int x = 0
  int y = 0
  private int id

  sum() int {
    return x + y
  }
}

# declare only, unmangled C symbol
extern fn getpid() int
extern fn abs(int n) int

# thread function
threads fn worker(int a) void {
    screen(a)
}

threads.waitAll()