Crate rulox

rulox

rulox is a lightweight scripting language embedded in Rust. It is based on the Lox language from Crafting Interpreters.

Examples

use rulox::prelude::*;
use rulox::LoxError;

fn main() -> Result<(), LoxError> {
    lox! {
        var a = 5;

        print a + 2;
    }

    let b: f64 = a.get()?.try_into().unwrap();

    println!("{}", b);

    Ok(())
}

lox! {
    for (var i = 5; i > 0; i = i - 1) print i;
}

lox! {
   fun hello(name) {
        print "Hello " + name + "! :)";
   }

    fun add_one(num) {
        return num + 1;
    }
}

hello.get()?.call([LoxValue::from("Alice")].into());

assert_eq!(add_one.get()?.call([LoxValue::from(3)].into())?, 4);

lox! {
    var people = ["Bob", "Alice", "John"];

    for (person in people) {
        print "Hello " + person + "!";
    }
}

lox! {
    class Person {
        init(name) {
            this.name = name;
        }

        say_hello() {
            print "Hello, my name is " + this.name + "!";
        }
    }

    var jane = Person("Jane");
    jane.say_hello();
}

lox! {
    class Person {
        init(name) {
            this.name = name;
        }

        say_hello() {
            print "Hello, my name is " + this.name + "!";
        }
    }

    class Telepath > Person {
        init(name, power) {
            super(name);
            this.power = power;
        }

        lift(weight) {
            if (this.power < weight) {
                print "It's too heavy!";
            } else if (this.power == weight) {
                print "I can't keep this up for long!";
            } else {
                print "This is child's play.";
            }
        }
    }

    var bob = Person("Bob");
    bob.say_hello();

    print "";

    var alice = Telepath("Alice", 4);
    alice.say_hello();
    alice.lift(1.5);
    alice.lift(4);
    alice.lift(10);
}

lox! {
    var except_ran = false;
    var else_ran = false;
    var finally_ran = false;
    try {
        print "try";
        throw 1;
    } except {
        print "except";
        except_ran = true;
    } else {
        print "else";
        else_ran = true;
    } finally {
        print "finally";
        finally_ran = true;
    }
}

Modules

prelude

Items that the lox macro expects to find in scope.

Macros

lox

Parses Lox code and converts it to Rust.

lox_bindgen

Generates a rulox binding for a Rust function.

rust_bindgen

Generates a Rust binding for a rulox function.

Structs

Coroutine

LoxArgs

Arguments to a Lox function.

LoxClass

A class defined in Lox code.

LoxError

An error raised during compilation or execution.

LoxFn

A function defined in Lox code.

LoxFuture

LoxVariable

A variable defined in Lox code.

MapKey

A hashmap key.

Enums

LoxValue

A dynamically typed value used by Lox programs.

Traits

Downcast

Objects which can be downcast to a concrete type.

LoxObject

A trait for foreign objects that can be used in Lox.

Type Aliases

DynLoxObject

A convenient alias for a LoxObject trait object.

LoxResult

A result returned from most Lox operations.

Shared

A shared, mutable pointer to T.

Derive Macros

TryFromLoxValue

Generates an implementation of TryFrom<LoxValue>.