Table of Contents

• Introduction
• Using qalam
• Syntax
  • Keywords
  • Conditionals
  • Loops
  • Objects (Classes)
• Types
• Native Functions
• Complete Example
• Speed

Introduction

As a learning exercise, to really hone my skills, I wanted to write a programming language myself. In order to accomplish this, I'm following the amazing tutorial called Crafting Interpreters by Robert Nystrom.

While Robert goes through the entire process, step-by-step, to create a programming language he calls Lox, I didn't want to simply follow a tutorial and copy-paste code. I have found that real learning occurs when you change up tutorials a little so that you can have a deeper understanding.

In order to do this, I decided to create my own syntax for the language with the same general features as Lox. I also decided to use Rust to make the language instead of Java so that I cannot possibly copy-paste code.

Using qalam

1. Install the qalam interpreter

cargo install qalam

2. Create a .qlm file with your source code

echo "qul \"hello world!\"" > main.qlm

3. Run the qalam code

qalam main.qlm
>> hello world!

Syntax

Keywords

niyya a = 1;
niyya b = 2;

amal add(a, b) {
  radd a + b;
}

qul add(a, b);
// prints 3

Conditionals

niyya a = haqq;
niyya b = batil;

shart(a wa b) {
  // do something
} ilshart(la a) {
  // do something
} illa {
  // do something
}

Loops

tawaf(niyya i = 0; i < 10; i = i + 1) {
  qul i; 
  // prints 0 to 9
}

niyya a = haqq;
niyya i = 0;
baynama(a) {
  shart (i < 10) {
    qul i;
    // prints 0 
    i = i + 1;
    safar;
  } illa {
    iftar;
  }
}

Objects (Classes)

kitab Animal {
  khalaq(name, sound) {
    nafs.name = name;
    nafs.sound = sound;
  }

  speak() {
    qul nafs.sound;
  }
}

kitab Feline ibn Animal {
  khalaq(name, sound) {
    ulya.khalaq(name, sound);
  }

  purr() {
    qul "purr"
  }
}

niyya cat = Feline("Hurayra", "Meow");
cat.speak();
// prints "meow"
cat.purr()
// prints "purr"

Types

Below are the built-in types supported by qalam:

Native Functions

I've implemented a few native functions to the program:

Complete Example

To showcase the functionalty of qalam, I've provided an example below of reversing a linked list:

kitab ListNode {
  khalaq(value, next) {
    nafs.value = value;
    nafs.next = next;
  }
}

amal list_to_string(head) {
  niyya string = "";
  niyya curr = head;
  baynama(curr != ghaib) {
    string += str(curr.value);
    shart(curr.next) {
      string += " -> ";
    }
    curr = curr.next; 
  }

  radd string;
}

niyya list = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5, ghaib)))));

amal reverse_list(head) {
  niyya prev = ghaib;
  niyya curr = head;
  niyya next = ghaib;
  baynama(curr != ghaib) {
    next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }

  radd prev;
}

qul "Original list:";
qul list_to_string(list);
qul "Reversed list:";
qul list_to_string(reverse_list(list));

Output

Original list:
1 -> 2 -> 3 -> 4 -> 5
Reversed list:
5 -> 4 -> 3 -> 2 -> 1

More Examples

I've provided many more examples, in the examples directory. You can run them with cargo run --example <name> or by running the main.qlm file inside the examples subdirectory with qalam <file_path>.

Speed

qalam is an interpreted language with dynamic types. However, since there are essentially zero optimizations done, it is extremely slow. I am also an extreme amateur when it comes to Rust programming, therefore, it is probably even slower than Robert's implementation in Java as I definitely did a million things wrong when using Rust.

In order to showcase how slow it actually is, I'll compare it's speed to JavaScript and Python (interpreted, dynamically typed languages). For the comparison, I'll use the calculation of the 30th fibonacci number using a recursive algorithm.

Below are the scripts for each language

Python

import time

def fib(n):
  if n <= 1:
    return n
  else:
    return fib(n - 1) + fib(n - 2)

start = time.time()
result = fib(30)
end = time.time()
print(f"{end - start}")

JavaScript

function fib(n) {
  if (n <= 1) {
    return n;
  } else {
    return fib(n - 1) + fib(n - 2);
  }
}

let start = Date.now() / 1000;
let result = fib(30);
let end = Date.now() / 1000;
console.log(`${end - start}`);

Qalam

amal fib(n) {
  shart(n <= 1) {
    radd n;
  } illa {
    radd fib(n - 1) + fib(n - 2);
  }
}

niyya start = clock();
niyya result = fib(30);
niyya end = clock();
qul(str(end - start));

Each test was run 10 times and the average runtime is tabulated below:

JavaScript and Python take less than second each. Qalam takes more than a minute. It is extremely slow, however, I am still proud that it works lol.