rust-langdev VS inko

Compare rust-langdev vs inko and see what are their differences.

rust-langdev

Language development libraries for Rust (by Kixiron)

inko

A language for building concurrent software with confidence (by inko-lang)
Our great sponsors
  • WorkOS - The modern identity platform for B2B SaaS
  • InfluxDB - Power Real-Time Data Analytics at Scale
  • SaaSHub - Software Alternatives and Reviews
rust-langdev inko
12 11
822 711
- 8.0%
3.2 9.4
21 days ago 6 days ago
Rust
The Unlicense Mozilla Public License 2.0
The number of mentions indicates the total number of mentions that we've tracked plus the number of user suggested alternatives.
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

Posts with mentions or reviews of rust-langdev. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-06-23.

inko

Posts with mentions or reviews of inko. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2023-11-14.
  • Inko Programming Language
    4 projects | news.ycombinator.com | 14 Nov 2023
    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.

    4 projects | news.ycombinator.com | 14 Nov 2023
  • Type inference of local variable based on later operations
    3 projects | /r/ProgrammingLanguages | 10 Jun 2023
    Inko's type checker, start at TypeChecker.check and work your way down the call stack. TypeChecker.check_type_ref is where most of the work is done.
    3 projects | /r/ProgrammingLanguages | 10 Jun 2023
    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
    4 projects | /r/rust | 5 Jun 2023
    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
    7 projects | news.ycombinator.com | 5 Jun 2023
    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 :)

What are some alternatives?

When comparing rust-langdev and inko you can also consider the following projects:

inkwell - It's a New Kind of Wrapper for Exposing LLVM (Safely)

codespan - Beautiful diagnostic reporting for text-based programming languages.

langs-in-rust - A list of programming languages implemented in Rust, for inspiration.

scala3-example-project - An example sbt project that compiles using Dotty

pratt - Pratt parser written in Rust

plzoo - Programming Languages Zoo

cranelift-jit-demo - JIT compiler and runtime for a toy language, using Cranelift

cats-parse - A parsing library for the cats ecosystem

marwood - An embeddable Scheme R7 Compiler & Runtime written in Rust

nom - Rust parser combinator framework

starlark-rust - A Rust implementation of the Starlark language

llrl - An experimental Lisp-like programming language