I was defeated by the Borrow Checker.

So, I’ve been writing my own programming language for the past few years. It’s gone through many rewrites, but I settled on the Rust programming language. Or so I thought.

So, I’ve been recently working on the Symbol Table, and apparently this is one of those things that are hard on Rust. Like linked lists, or any other data structure. But wait! There is a solution! RefCell! Right? Right?

The inner mutability problem?

So, I have a node (a scope, really):

struct Scopes<'a> {
    scopes: RefCell<HashMap<String, SymbolTableScope<'a>>>,
}

struct SymbolTableScope<'a> {
    scope_id: String,
    members: RefCell<HashMap<String, Type>>,
    parent_scope: Option<String>,
}

A scope has members: variables and what type they are, a scope id, and a optional parent.

So now, I want to look for a symbol on the current scope, and if it’s not there, look on the parent scopes.

impl SymbolTableScope<'_> {
    pub fn get_type(&self, symbol_name: &String) -> Some(???) {
        match self.get(symbol_name) {
            Some(t) => Some(t),
            None => {
                match self.parent_scope {
                    Some(parent) => parent.get_type(symbol_name),
                    None => None
                }
            }
        }
    }
}

The code is not exactly what I wrote, but the concept is there. I get an error:

error[E0515]: cannot return value referencing temporary value

And I get it (at least I think I do), but I haven’t found a way to solve it. I cannot clone it, I cannot solve it with lifetimes, nothing comes to mind. And even if cloning worked, eventually I’ll want to remove all cloning for performance.

So, what to do?

Debugging my programming language knowledge rather than my application

So, I admit defeat. The borrow checker defeated me. Maybe I’m not smart enough, maybe I need to go through the book again. But at this point, I’d say 30% of my time went to fight the borrow checker. That is 30% of time that didn’t go into features, tests, bug fixes, documentation, and so on.

And sure, the borrow checker gives you safety like no other language does. But is it worth it? how many compilers were written on C/C++? Did we not do systems programming before Rust?

I think I’ve reached a point where I cannot justify using Rust anymore. Rust is amazing for small to medium programs, but it seems like as soon as you need both performance and multiple mutability, Rust becomes a slowdown. So, I’ve decided I will be rewriting my language, yet again, probably in Zig. I will specially miss the ariadne and rustyline crates, they made my life and compiler so much better. But alas, so long and thanks for all the fish.

Thank you Rust, welcome Zig

I will now rewrite my compiler in Zig. As always, I am going in without being a master in the language, but that’s the fun part.

If Zig fails me maybe I’ll settle on Go or smt, idk