qalam

Roman urdu inspired, interpreted programming language written in Rust.

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.

[!NOTE] Some of you who have been here before remember that Qalam was very different before. It was "Islamic/Arabic terminology inspired". I decided to change the syntax because this project is more of learning exercise/joke than a real-world or useful product. For this reason, I thought that it's not very appropriate to use Islamically inspired syntax for something that is a joke.

All of this worked out because Qalam actually means the same thing in both Urdu and Arabic, pen.

Using qalam

1. Install the qalam interpreter

cargo install qalam

2. Create a .qlm file with your source code

echo "bolo \"sab ko salam!\"" > main.qlm

3. Run the qalam code

qalam main.qlm
>> hello world!

Syntax

Keywords

rakho a = 1;
rakho b = 2;

kaam add(a, b) {
  wapis a + b;
}

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

Conditionals

rakho a = sach;
rakho b = jhoot;

agar(a aur b) {
  // do something
} warna {
  // do something
}

Loops

har(rakho i = 0; i < 10; i++) {
    bolo(i); // prints numbers 0 - 9
}

rakho i = 0;
jabtak(i < 0) {
    bolo(i); // prints numbers 0 - 9
}

Objects (Classes)

jamat Shaks { // Person
    banao(naam) {
        yeh.naam = naam;
    }

    taruf() { // introduce
        // my name is + this.name
        bolo("Mere naam " + yeh.naam + " hai!"); 
    }
}

jamat Student shamil Shaks {
    banao(naam, subject) {
        asli.banao(naam);
        yeh.subject = subject;
    }

    taruf() {
        asli.taruf()
        // I am studying + this.subject
        bolo("Mai " yeh.subject + " par ta hoon.");
    }
}

rakho admi = Shaks("Ammar");
rakho engineer = Student("Amir", "Engineering");

admi.taruf();
// prints Mere naam Ammar hai!

engineer.taruf(); 
// prints 
// Mere naam Amir hai!
// Mai Engineering par ta hoon.

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:

jamat ListNode {
  banao(value, next) {
    yeh.value = value;
    yeh.next = next;
  }
}

kaam list_to_string(head) {
  rakho string = "";
  rakho curr = head;
  jabtak(curr != khali) {
    string += str(curr.value);
    agar(curr.next) {
      string += " -> ";
    }
    curr = curr.next; 
  }

  wapis string;
}

rakho list = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5, khali)))));

kaam reverse_list(head) {
  rakho prev = khali;
  rakho curr = head;
  rakho next = khali;
  jabtak(curr != khali) {
    next = curr.next;
    curr.next = prev;
    prev = curr;
    curr = next;
  }

  wapis prev;
}

bolo("Original list:"));
bolo((list_to_string(list));
bolo("Reversed list:");
bolo(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

kaam fib(n) {
  agar(n <= 1) {
    wapis n;
  } warna {
    wapis fib(n - 1) + fib(n - 2);
  }
}

rakho start = clock();
rakho result = fib(30);
rakho end = clock();
bolo(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 half a minute. It is extremely slow, however, I am still proud that it works lol.