Azkal Language

A programming language built from scratch in TypeScript, featuring closures, objects, arrays, template strings, pipe operator, destructuring, and more.

Installation

npm install -g azkal-lang

Then run files with azkal myfile.azkal or start the REPL with just azkal.

Hello World

print("Hello, World!")

Save as hello.azkal and run with azkal hello.azkal.

Variables

Declare variables with let. Azkal uses block scoping.

let name = "Azkal"
let age = 1
let active = true
let nothing = null

// Reassign
name = "Azkal v2"

// Block scoping
{
  let x = "inner"
  print(x)  // "inner"
}
// x is not accessible here

Types

Azkal has 7 types: number, string, boolean, null, array, object, function.

type(42)         // "number"
type("hello")    // "string"
type(true)      // "boolean"
type(null)      // "null"
type([1,2])     // "array"
type({a:1})     // "object"
type(fn(){})    // "function"

Functions

Functions are first-class values. Declare with fn.

// Named function
fn add(a, b) {
  return a + b
}

// Anonymous function
let double = fn(x) { return x * 2 }

// Default parameters
fn greet(name = "World") {
  print(`Hello, {name}!`)
}
greet()           // Hello, World!
greet("Azkal")    // Hello, Azkal!

// Closures
fn counter() {
  let n = 0
  return fn() {
    n = n + 1
    return n
  }
}
let c = counter()
print(c())  // 1
print(c())  // 2

Control Flow

If / Else

if x > 0 {
  print("positive")
} else if x == 0 {
  print("zero")
} else {
  print("negative")
}

While Loop

let i = 0
while i < 10 {
  print(i)
  i = i + 1
}

For...In Loop

for item in [1, 2, 3] {
  print(item)
}

for ch in "hello" {
  print(ch)
}

for key in {a: 1, b: 2} {
  print(key)
}

Use break and continue to control loop execution.

Arrays

let nums = [1, 2, 3, 4, 5]
nums[0]        // 1
nums.length    // 5

// Spread
let merged = [...nums, 6, 7]

Objects

let user = {
  name: "alky",
  level: 99
}
user.name       // "alky"
user["level"]   // 99
user.hp = 100   // add new property

// Shorthand
let x = 10
let y = 20
let point = { x, y }  // { x: 10, y: 20 }

Strings

let s = "Hello, World!"
s[0]          // "H"
s.length      // 13

Template Strings

Use backticks with {expr} for interpolation.

let name = "world"
print(`Hello, {name}!`)
print(`2 + 2 = {2 + 2}`)

// Nested expressions
print(`{name.upper()} has {name.length} chars`)

Destructuring

Extract values from arrays and objects into variables.

Array Destructuring

let [a, b, c] = [1, 2, 3]
print(a)  // 1
print(b)  // 2
print(c)  // 3

// Extra names get null
let [x, y] = [10]
print(y)  // null

Object Destructuring

let user = { name: "alky", age: 25 }
let { name, age } = user
print(name)  // "alky"
print(age)   // 25

Pipe Operator

The pipe operator |> passes the left value as the first argument to the right function.

42 |> str             // "42"

5 |> fn(x) { return x * 2 }
  |> fn(x) { return x + 1 }
  |> print             // 11

// Great for data pipelines
[1, 2, 3, 4, 5]
  .filter(fn(x) { return x > 2 })
  .map(fn(x) { return x * 10 })

Error Handling

Use try/catch to handle runtime errors gracefully.

try {
  let result = 1 / 0
} catch (e) {
  print(`Caught: {e}`)
}

// Catch undefined variables
try {
  print(unknown_var)
} catch (e) {
  print("Variable not found")
}

The catch variable e contains the error message as a string.

Comments

// Single-line comment

/* Multi-line
   block comment */

let x = 1 /* inline */ + 2

Operators

String concatenation with + works when either operand is a string.

Standard Library

Math