inko
gleam
inko | gleam | |
---|---|---|
11 | 96 | |
742 | 15,033 | |
3.6% | 5.1% | |
9.4 | 9.9 | |
5 days ago | 4 days ago | |
Rust | Rust | |
Mozilla Public License 2.0 | Apache 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.
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.
gleam
-
Borgo is a statically typed language that compiles to Go
I haven't had time to really try to write anything in it, but https://gleam.run/ looks really good too. Like Elm for backend + frontend!
-
Release Radar • March 2024 Edition
Want a friendly language for building safe systems at scale? Gleam is here for you. It features modern and familiar syntax, that's reliable and scalable. Gleam runs on an Erlang virtual machine, and can run plenty of concurrent tasks. It comes with a compiler, build tool, formatter, editor integrations, and package manager all built in so you can get started right away. Congrats to the team on shipping your first major version 🙌.
-
The Current State of Clojure's Machine Learning Ecosystem
While I love Clojure, I have to agree about tooling. I recently started using Gleam* and was impressed at how easy it was to get up and running with the CLI tool. I think this is an important part of getting people to adopt a language.
* https://gleam.run/
-
Show HN: I open-sourced the in-memory PostgreSQL I built at work for E2E tests
If you use languages that compile to WASM (such as Gleam https://gleam.run), and can also run Postgres via WASM, then it opens very interesting offline scenarios with codebases which are similar on both the client and the server, for instance.
-
Why the number of Gleam programmers is growing so fast?
Recently, Gleam has gained more popularity, and a lot of developers (including me) are learning it. At the time of this writing, it has exceeded 14k stars on GitHub; it grew really fast for the last month.
- Cranelift code generation comes to Rust
- Gleam v1.0.0
- Gleam has a 1.0 release candidate
-
Welcome to the Gleam Language Tour
Oh, strange that github had a date of 2016 on this one: https://github.com/gleam-lang/gleam/issues/2
I was just going by that, though I do remember checking out gleam 5 years ago or so.
Re: macros, I really do think they’re a big deal and all the other newer languages I’ve used, such as Rust have some kind of macros or powerful meta programming features.
For older languages, a few, like Ruby have enough meta programmability to make nice DSLs, but many others don’t. Given the choice, I’d much rather have Elixir/Clojure style macros than other meta-programming facilities I’ve seen so far.
-
Inko Programming Language
I had been only following this language with some interest, I guess this was born in gitlab not sure if the creator(s) still work there. This is what I'd have wanted golang to be (albeit with GC when you do not have clear lifetimes).
But how would you differentiate yourself from https://gleam.run which can leverage the OTP, I'd be more interested if we can adapt Gleam to graalvm isolates so we can leverage the JVM ecosystem.
What are some alternatives?
llrl - An experimental Lisp-like programming language
are-we-fast-yet - Are We Fast Yet? Comparing Language Implementations with Objects, Closures, and Arrays
rust-langdev - Language development libraries for Rust
web3.js - Collection of comprehensive TypeScript libraries for Interaction with the Ethereum JSON RPC API and utility functions.
lltz - LLTZ: Compiler from MLIR to Michelson
Rustler - Safe Rust bridge for creating Erlang NIF functions
brainfk-rs - Compiles brainfuck to wasm!!
ponyc - Pony is an open-source, actor-model, capabilities-secure, high performance programming language
logic - Logic backend implementation for Robot Rumble
nx - Multi-dimensional arrays (tensors) and numerical definitions for Elixir
parser - A Ruby parser.
hamler - Haskell-style functional programming language running on Erlang VM.