Right now we have the true and false keywords reserved, but they won't parse into an expression

I think any modern language aiming for success needs a package manager.

I thought of a clever name for it: “Loy”

As in dep... loy

Haha oh god I’m not funny

Right now, headers are not added to the libraries, which means they don't show up in VS

Right now I believe we only support operators with one character. Obviously there can be multi character operators like && or ->

Right now the return types of our functions are ambiguous

Note, this will actually require parsing of multi-character operators #2 for ->

Right now we're just doing parsing, but once we get into semantics obviously we'll have to check that a void function cannot be used as an expression

We can use the symbol table to verify that operators and assignments are using valid types. This may be broken down into several other issues later

Should be similar to what we did with the expression parser, recursive descent style

Right now, the implementation of ParseBinOpRHS partially uses recursion and iteration. I think it would be cleaner if it used just recursion

Right now are expect error messages say what key was found versus what was expected, but using the integer values of the enums, so it's completely unreadable

Right now the Lexer only takes input from stdin, but I'd like you to be able to embed it in a program other than an interpreter, like an IDE where it could be fed custom lines.

Also, there should be a reset method on the Lexer that allows you to clear the "chambered" currTok, so that if you're doing a bunch of short queries, you're sure that they are treated separately. That, or make all of the maps static and then just destruct the instance. Actually, on second thought this is a much better idea, I'll do this if I get time.

We need this so that the symbol table can visit ASTs even if they only know the base class, not which derived class it is

I think that this can be implemented by integrating it into the parser, so when a statement is successfully parsed, you just get the AST like before, but now we guarantee that this is a semantically valid statement.

This would mean that the parser would own the symbol tables and that sounds... not right, but hey I'm not a compiler expert

If we run into an error, we log the error and return null

We need to be able to express the idea of a statement, i.e. a command that does something, not just representing a value.

Mainly, we need to be able to define new variables