craftinginterpreters | Repository for the book `` Crafting Interpreters | Interpreter library

I know this is well trodden territory but I have a specific question... I promise.

Having spent very little time in the statically typed, object oriented world, I recently came across this design pattern while reading Crafting Interpreters. While I understand this pattern allows for extensible behavior (methods) on a set of well defined existing types (classes), I don't quite get the characterization of it as a solution to the double dispatch problem, at least not without some additional assumptions. I see it more as making a tradeoff to the expression problem, where you trade closed types for open methods.

In most of the examples I've seen, you end up with something like this (shamelessly stolen from the awesome Clojure Design Patterns)

What "Native functions" means or refers to, in a programming language?

I am reading the book "Crafting Interpreters" by Robert Nystrom where he has a list on Github with all Lox's implementations that other readers have done in other languages. I saw that one of that list says that it does not have native functions and I would like to know what it means about that?

https://github.com/munificent/craftinginterpreters/wiki/Lox-Implementations

I was trying to write my own VM implementation in C++ from the excellent book Crafting Interpreters.

The book builds a stack based virtual machine, of which I am writing a C++ version

So here is the code where the compiler is yelling at me.

object.h

Came across this while trying to follow the excellent Crafting Interpreters book but using Rust instead of C.

The book builds a stack based virtual machine, of which I have a simple Rust version that looks something like:

I'm trying to build a C compiler from scratch. Googling took me to the https://craftinginterpreters.com/ site. There are a lot of explanations how source code parsers work in detail. I've reached "Parsing expressions" chapter and stuck in this.
They offer that algorithm of creating parse tree (recursive descend)

I've been writing a tad of C lately. I haven't had too much experience throwing everything into headers, writing their implementations, etc - but I thought I knew enough. At least, until today :P

Long story short - I'm getting an error of 'conflicting types for ValueArray' - but it points me to the same line for the previous declaration.

It repeats that for a handful of declarations in that same file, and then declarations in another file as well.

P.S. The error is not underlined in CLion as well.

I'm trying to implement a programming language in Common Lisp by following this implementation in Java (https://craftinginterpreters.com/control-flow.html).

One of the things that was being really bothersome is plenty of slot-values everywhere.

Granted I can add a line in each function with with-slots, but that's also repetitive, and given that my symbols are not :used but I refer to them by the package, as there is plenty of symbols from many modules and I don't want to lose track from where they come from, even with-slots requires the full qualified name. All this seems to me like very bad code smell.

I googled and found rutils. With its @object.slot accessor I managed to clean up my code immensely. Just look at the last commit https://github.com/AlbertoEAF/cl-lox/commit/84c0d62bf29bff9a2e0e77042a9108c168542b96?diff=split excerpt:

(I could paste the code but all of it is available on that repo, I wanted to show the diff highlights)

Not only it removes some characters, but more importantly, there's one less level of depth (slot-value call) and parenthesis to think about - which helps a lot but for the trivial functions.

It gets worse when I have lots and lots of symbol names and can no longer export them all because I start having conflicts in symbols.

Can you guys give me input on the code? This looks much better now but I'm curious as if to are better ways to go about it?

Thanks!

I found myself calling lots of methods whose first argument is a complex object from a given class. Whilst with-slots and with-accessors are useful, generic methods cannot be bound in this way. So I thought: if we could locally curry any functions, slots + accessors + generic functions + functions could all be addressed with the same construct.

Example of code I want to clean up:

I am studying on how to make a bytecode interpreter (the language i am studing is clox at the site https://craftinginterpreters.com/). In it a valid clox program is defined as a list of declarations. A declaration is defined as either a class, function or variable declaration OR as a statement.

Now in C, i know there are different kinds of declarations and there are different kinds of statements but none of the types of declarations are a statement and none of the type of statements are a declaration. I think any possible line of C code is either one or the other so how do the standard define a C program ?

A list of lines that can be either a definition or a statement ?