joajfreitas / flox

Bytecode interpreted LISP in Rust

flox

Lisp interpreter implemented as a stack based bytecode virtual machine.

The implementation is based on the Crafting Interpreters book by Robert Nystrom.

Running

cargo run --bin main

Tests

cargo test

flox's Issues

Garbage collector

Extend CI

Include:

• clippy warnings
• build warnings
• pin the toolchain
• code coverage

Use binary target instead of examples

Bytecode compiler functions have no way to signal errors

Create some sort of documentation for the language and its standard library

Keep state between lines in REPL

>> (set! x 10)
>> x

Currently doesn't work since the state is cleared between the two inputs

Arity check for functions

Remove need for (apply f args)

Create a README

CLI flag for debug

(/ 2 3) == 0.7

Move spec tests to rust tests

Implement recursive Fibonnaci in flox

Benchmark against python, flang and Lua implementation

Add CI to the project

• Run cargo build
• Run cargo test
• Run cargo run --example test test/specs/base.json
• Check formatting with rustfmt

Implement support for lists

Handle failure in REPL mode

• Command failure causes the REPL to crash
• EOF also causes the repl to fail

Both of these should be handled so that the session can proceed

Measure memory usage

• Size of Element struct
• Size of Value

Check how the stack grows

Implement defun

Implement functions

Frontend

(lambda (x) (+ x 1))

Backend

Support OpCall bytecode instruction

Implement closures

(lambda (x) (lambda (y) (+ x y))

In this type of construct the inner lambda is not able to access the x variable

Implement code coverage and reach 100%

https://github.com/xd009642/tarpaulin

Implement C FFI