Inko Alternatives

inko reviews and mentions

• A language like C, but with a borrow-checker
  1 project | news.ycombinator.com | 18 Nov 2023
• Ask HN: Which language will you try for this year's Advent of Code and why?
  1 project | news.ycombinator.com | 15 Nov 2023
• 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.

• Type inference of local variable based on later operations
  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 :)

• Does modern implementation use tagged pointers/values?
  1 project | /r/ProgrammingLanguages | 27 May 2023

  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
  1 project | /r/ProgrammingLanguages | 17 Apr 2023

  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
  1 project | /r/rust | 14 Apr 2023

  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.

• A note from our sponsor - SaaSHub
  www.saashub.com | 18 Apr 2024

  SaaSHub helps you find the best software and product alternatives Learn more →