luukdegram / luf Goto Github PK

Function declarations should be declared as public or private by default within the global scope

Would be cool to be able to write Luf code, and compile to WASM, rather than having to write WASM code directly. Especially because Luf has type-safety and is a lot more readable than WASM text.

Currently we store the whole instruction since a list, but it would save some memory if we were to simply store the index of the instruction

• Add function's name to exported functions (so we can look them up in globals list)
• Implement the call() function
• Implement translation from Zig to Luf for call arguments

Some instructions can easily be optimized such as:

const x = 5 + 5 can be optimized to const x = 10.
const myFunc = fn() { return 5 } can be optomized to return 5.

Luf already supports nil literals, but assigning nil to a variable will make its type nil as well.
Optional should be seperate type that must be handled before usage, similair to how Zig handles them.

Currently error messages require to be comptime known, cuasing us to lose runtime known information, such as an en expected type. By allocating them we can use std.fmt.allocPrint() to make fancy error messages.

Ensure we do not forget to free all memory created by those messages. Either by deinit() or when write() is called.

Adding support for debug symbols will allow us to print error traces for runtime errors.

Currently all tests are handwritten within Zig with a lot of expects().
This is not really manageable, and takes quite some work to update on changes.
We should look into behavioral tests.

Currently, the user would have to create their own Zig project first, and embed the VM to be able to write Luf code. Luf should also come as a standalone CLI tool that can run both Luf files as well as compiled bytecode for faster execution using flags.

Currently, all imported functions have as type module. This causes errors during type checking.
This depends on #10.

It would be a cool experiment to compile to typed ZIR that can be used by Zig's compiler to compile it to machine code and see its effect on performance compared to regular Zig code.

Obviously we will have to comply with Zig's semantics and type system, allowing us to only implement features that are supported by Zig. We will also have to handle memory usage someway.

This is required so we can do type checking on imported modules.

• Add compiler support for 'packages' for type support. (compiler doesn't know anything about this package, therefore we should ignore type checking for those cases but return a general .module type or something like that).
• Add function to value.zig to wrap a Zig function into a Luf Value.
• Add VM support to add Zig functions as a 'package'.