quilt

quilt copied to clipboard

About

Quilt is a hobby project of mine. I designed it to be a simple, with a syntax similar to rust and python. I needed a language that I could use within my own projects that could be easily embedded and extended. I also wanted to learn more about how to build a programming language.

crafting interpreters was a great resource during the development of the backend.

Features

• Dynamically typed
• Bytecode interpreter
• First class functions
• Closures
• Extendable native rust builtins
• Relatively fast (about 1.5x - 2.5x slower than python to calculate fib(30) & fib(40))
• Python style dissasembler

Roadmap

• optimizations (ie, loop unrolling, tail call optimization, etc)
• Spread operator
• Short circuiting
• break and continue statements
• error handling (try /catch)
• ~~repl~~

Installation

clone the repo

git clone https://github.com/nathanielfernandes/quilt

install the binary

cargo install --path ./cli

Usage

once installed, you can run the binary with a file path

quilt main.ql

the binary also as a few options, check them out with

quilt --help

Examples

// includes
include "std/math.ql"

// recursion
fn fib(n) {
    if n < 2 {
        return n
    }

    return fib(n - 1) + fib(n - 2)
}

fib(30)


// switch case statements
fn fib(n) {
    switch n {
        case 0, 1 {
            n
        }

        default {
            fib(n - 1) + fib(n - 2)
        }
    }
}

fib(20)

// loops
let i = 0
// assignements are expressions (as well as if statements and loops)
let res = while (i = i + 1) < 10 {
    i * 20
}

// native rust function
@print(res)

// for loops
for i in 0:10 {
    for j in [1, 2, 3, i] {
        @print(i, j)
    }
    @print(i)
}

// destructuring
let a, b = (1, 2)
for a, b, c in [[1, 2, 3], [4, 5, 6], [7, 8, 9]] {
    @print(a, b, c)
}

// closures
fn NewCounter() {
    let count = 0

    fn Increment() {
        count += 1
    }

    fn Decrement() {
        count -= 1
    }

    // lambdas
    let Get = fn() { count }

    // implicit return
    [Increment, Decrement, Get]
}

let incr, decr, get = NewCounter()

Complete errors, with tracebacks:

Disassembler Output

fn fib(n) {
    if n < 2 {
        n
    } else {
        fib(n - 1) + fib(n - 2)
    }
}

fib(30)

Builtin Functions

Builtins can be created with an easy to use macro. The macro will generate the callable functions and put them all into the same module. The module can then be added to the vm.

generate_builtins! {
    [export=math] // builtin module name

    ///Compute the sqrt of a number.
    fn @sqrt(a: num) -> float {
        Value::Float(a.sqrt())
    }

    ///Get a random number between 0 and 1.
    fn @random() -> float {
        Value::Float(rand::random())
    }

    ///Get a random integer between two values.
    fn @randint(start: int, end: int) -> int {
        if start >= end {
            Err(error("start must be less than end"))?
        }

        Value::Int(rand::thread_rng().gen_range(start..end))
    }

    ///Get a random float between two values.
    fn @randfloat(start: double, end: double) -> float {
        if start >= end {
            Err(error("start must be less than end"))?
        }

        Value::Float(rand::thread_rng().gen_range(start..end))
    }

    ///Compute the luminance of a color.
    fn @luma(c: color) -> float {
        Value::Float(c[0] as f64 * 0.2126 + c[1] as f64  * 0.7152 + c[2] as f64  * 0.0722)
    }

     ///Truncate a string to a given length and add a custom ellipsis.
    fn @truncate(s: str, len: int, ?ellipsis: str = String::from("...")) -> str {
        ...
    }
}

// custom mutable state
let state: i32 = 0;
let ops = VmOptions::default();

let mut vm: VM<i32> = VM::new(state, script, ops);

vm.add_builtins(math);

ByteCode