Creating a new language with Rust without Garbage Collection?

Question

I am new to language development. I am aware of Rust's ownership model that builds programs in a way that does not need garbage collection.

So if I am to build a new programming language using safe Rust exclusively, will it be that the programming language will not need for me to implement garbage collection?

Here is the context;

I want to create an interpreted language. I have decided to either use Nim or Rust.

I love Nim's syntax and find it fun to work with. I also hear interesting things concerning Rust, especially regarding its safety features.

So my questions are;

1. Does using Rust eliminate the need to implement garbage collection in a language? If not, what other benefits do you think one can get by using Rust for working on an interpreted language?

2. If I am to use Nim, what exactly will I be losing (or gaining) over rust?

Answer 1

Does using Rust eliminate the need to implement garbage collection in a language?

No. Rust’s memory management relies on semantic properties of the language that are carefully guaranteed. Unless your language is implemented as an embedded domain-specific language within Rust (that is, it is “just” a Rust library, perhaps with some fancy macros to provide sugar), you cannot easily inherit these guarantees from the host language, so you will still have to worry about your language’s memory management in the usual way.

If your language is interpreted, and you wish to remain within the safe subset of Rust, you will somehow have to prove to the borrow checker that values of your language have well-defined lifetimes. Depending on the semantics of your language, this may be tricky to do. On the other hand, if your language is compiled, Rust’s memory management has little impact on the memory and lifetime semantics of your language, as you are free to produce whatever code you’d like.

If your language is intended to support fully automatic memory management without explicit lifetimes, then an interpreter is likely to be easier to implement in a garbage collected language, as it is possible to reuse the garbage collector of the host language in that case. However, again, if your language is compiled, the memory management of the host language is essentially irrelevant.

If not what other benefits do u think one can get by using Rust for working on an interpreted language. […] If I am to use Nim what exactly will I be missing out (or benefiting) on if I choose to use Nim or Rust to implement a language.

These questions are not on-topic on this site, as they are extremely broad and in some cases essentially come down to opinion. Also, more broadly, it’s best to only ask one question per question on Stack Exchange sites. See our Help Center for what types of questions you can ask here.

Answer 2

No, while rust's safety model will prevent many types of memory errors like use-after-free, it does not prevent memory leaks. From the Rust book:

Rust’s memory safety guarantees make it difficult, but not impossible, to accidentally create memory that is never cleaned up (known as a memory leak). Preventing memory leaks entirely is not one of Rust’s guarantees in the same way that disallowing data races at compile time is, meaning memory leaks are memory safe in Rust. We can see that Rust allows memory leaks by using Rc and RefCell: it’s possible to create references where items refer to each other in a cycle. This creates memory leaks because the reference count of each item in the cycle will never reach 0, and the values will never be dropped.

You can trivially create a memory leak by creating a cycle with an Arc<T>/Rc<T>. Also functions like std::mem::forget are considered safe even though they may leak memory.

A language implemented only in safe rust will inherit rust's safety guarantees, but will still leak memory as that isn't one of the guarentees. If you want memory usage to stay within limits you need some system to detect leaked objects and free them (eg. a Mark and Sweep Garbage Collector)

You don't need a garbage collector though, if you are willing to accept leaks can happen and are not much of a problem. PHP for example uses only reference counting to free objects which means it will leak memory in much the same situations as rust would. If you are a language intended to be used for short scripts it may not be a huge problem.

Further reading:

• One
• Two

Answer 3

Does using Rust eliminate the need to implement garbage collection in a language?

No. The language in which a language is implemented has almost nothing to do with the properties of the implemented language. Rust was originally written in OCaml, for example, but OCaml is garbage collected and Rust is not.

If I am to use Nim, what exactly will I be losing (or gaining) over Rust?

As you noted, Nim is garbage collected (reference counted) and does not use an ownership system for anything other than eliding reference counts. There are some data structures that are difficult to represent in an ownership system like Rust, notably trees. If you use a tree to represent any part of your language - and you likely will - it's probable that you will run into difficulties with the borrow checker, especially starting off, or have to fall back on using Rc and Arc to form a reference-counted structure. (a possible alternative is to instead represent trees as Vecs)

Rust is descended from the ML family of languages, however, and inherited many of their features that make them nice for building languages (ML: literally "Meta Language"). The combination of Rust's struct and enum types allow for the modelling of many data structures useful for implementing a language, while its match statement allows for structurally decomposing them. These are heavily inspired by ML's data/type/datatype and match/case/of constructs.

Rust's struct is directly equivalent to Nim's object. Rust's enum has no direct equivalent. Instead, Nim has "object variants": structs that have a tag that can be matched upon to access different fields. This means that fields can be shared across variants, unlike Rust's enum, but the tag must be explicitly defined separately. This is generally a little harder to work with. Nim also does not have structural pattern matching: its case/of statement can only match upon ordinal types and strings (though, there are libraries that extend it to work structurally).

There's not a right or wrong choice, of course, and there are many examples of languages implemented in both, but hopefully that provided some exposition as to what language features make a language suitable for implementing other languages in.

Answer 4

Rust does not provide garbage collection out of the box. But when you write a new language in Rust, the new language may require garbage collection. You can not write a Scheme interpreter without implementing a garbage collector. Whether you need a garbage collector depends on the language you want to implement. Rust does not require one, but other languages require one. And if the new language requires garbage collection, Rust's borrow semantics will not help. You have to write a garbage collector in Rust in the same way people wrote garbage collectors in C.