rust-langdev
inko
Our great sponsors
rust-langdev | inko | |
---|---|---|
12 | 11 | |
833 | 742 | |
- | 6.9% | |
3.2 | 9.4 | |
about 2 months ago | about 24 hours ago | |
Rust | ||
The Unlicense | Mozilla Public License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
rust-langdev
-
Is this a good way to free up some memory?
If you're doing lang dev, maybe check out https://github.com/Kixiron/rust-langdev. I haven't done much since college, not in rust, but I've heard good things
-
loxcraft: a compiler, language server, and online playground for the Lox programming language
rust-langdev has a lot of libraries for building compilers in Rust. Perhaps you could use these to make your implementation easier, and revisit it later if you want to build things from scratch. I'd suggest logos for lexing, LALRPOP / chumsky for parsing, and rust-gc for garbage collection.
-
Should I revisit my choice to use nom?
https://github.com/Kixiron/rust-langdev is a pretty nice list of libraries for Rust lang dev including parsers.
-
Tools for creating a programming language in rust
Someone showed me this repo with a bunch of lang dev libraries a while ago. I haven't done anything with it personally, but it may be of interest to you https://github.com/Kixiron/rust-langdev
- Rust libraries to build a compiler for my language?
- Good textbook with implementations of OO type system?
- Language Development Libraries for Rust
- How to write a compiler or interpreter in rust
-
Make A Langage
https://github.com/Kixiron/rust-langdev for additional resources and libraries
-
Can i use rust to write my compiler??
Absolutely. For a non-exhaustive list of other languages written in Rust, there is https://github.com/alilleybrinker/langs-in-rust. If you are looking for libraries to help you along the way, check out https://github.com/Kixiron/rust-langdev.
inko
- A language like C, but with a borrow-checker
- Ask HN: Which language will you try for this year's Advent of Code and why?
-
Inko Programming Language
I have mixed feelings on Rust's syntax, especially around generics, lifetimes, and the `modifier -> keyword` syntax (i.e. `async fn` or `pub fn`). For Inko, I wanted something that's easy to parse by hand, and no context specific parsing (e.g. `QUOTE -> something` being the start of a lifetime in one place, but a char literal in another place).
Another motivator for that is that years ago I worked on Rubinius for a while (an implementation of Ruby), and helped out with a parser for Ruby (https://github.com/whitequark/parser). The Ruby developers really liked changing their already impossible syntax in even more impossible ways on a regular basis, making it a real challenge to provide syntax related tools that support multiple Ruby versions. I wanted to avoid making the same mistake with Inko, hence I'm actively trying to keep the syntax as simple as is reasonable.
As for the specific examples:
- `fn async` means your parser only needs to look for `A | B | fn` in a certain scope, instead of `A | B | fn | async fn`. This cuts down the amount of repetition in the parser. An example is found at https://github.com/inko-lang/inko/blob/8f5ad1e56756fe00325a3..., which parses the body of a class definition.
- Skipping parentheses is directly lifted from Ruby, because I really like it. Older versions took this further by also letting you write `function arg1 arg2`, but I got rid of that to make parsing easier. It's especially nice so you can do things like `if foo.bar.baz? { ... }` instead of `if foo().bar().baz?()`, though I suspect opinions will differ on this :)
- Until recently we did in fact use `::` as a namespace separator, but I changed that to `.` to keep things consistent with the call syntax, and because it removes the need for remembering "Oh for namespaces I need to use ::, but for calls .".
- `[T]` for generics is because most editors automatically insert a closing `]` if you type `[`, but not when you type `<`. If they do, then trying to write `10<20` is annoying because you'd end up with `10<>20`. I also just like the way it looks more. The usual ambiguity issues surrounding `<>` (e.g. what leads to `foo::()` in Rust) doesn't apply to Inko, because we don't allow generics in expressions (i.e. `Array[Int].with_capacity(42)` isn't valid syntax) in the first place.
-
Type inference of local variable based on later operations
Inko supports this in its type checker. The implementation is both surprisingly simple and tricky, and works roughly as follows:
-
The Rust I Wanted Had No Future
Perhaps it's worth looking into Inko? I apologise if I'm shilling my own project a bit too hard here, but reading through the comments it does seem people would be interested in what it's trying to do :)
-
The Rust I wanted had no future
Perhaps you'd be interested in Inko (https://inko-lang.org/). It's obviously not there yet in terms of tooling and what not, but it might scratch an itch for those looking for something a bit like Rust, but easier to use.
Disclaimer: I'm the author of said language :)
-
Does modern implementation use tagged pointers/values?
Inko currently uses tagged pointers, though this is a remnant from when it was still using a VM. I'm working on replacing this with a better solution. In short: for a compiled language I don't think there's really a benefit to using pointer tagging.
-
"Linear style" and the spectrum of zero-cost to memory safety overhead
I think Inko shows this behavior too, where a linear-style program suddenly has zero cost. (Yorick, sanity check me on this?)
-
Thoughts on designing a stack base VM and byte code
For opcodes you can also use a third option: you use a single struct for all opcodes, and size it to support a fixed number of arguments. Most opcodes probably won't need more than 4-5 arguments. If those argument values are small enough (e.g. u16), you don't need that much space. You can find an example of this here, with the Instruction type only taking up 12 bytes.
What are some alternatives?
inkwell - It's a New Kind of Wrapper for Exposing LLVM (Safely)
llrl - An experimental Lisp-like programming language
codespan - Beautiful diagnostic reporting for text-based programming languages.
lltz - LLTZ: Compiler from MLIR to Michelson
scala3-example-project - An example sbt project that compiles using Dotty
brainfk-rs - Compiles brainfuck to wasm!!
langs-in-rust - A list of programming languages implemented in Rust, for inspiration.
logic - Logic backend implementation for Robot Rumble
pratt - Pratt parser written in Rust
parser - A Ruby parser.
plzoo - Programming Languages Zoo
mioco - [no longer maintained] Scalable, coroutine-based, fibers/green-threads for Rust. (aka MIO COroutines).