We're happy to announce that the Vale 0.2 beta now has const generics! Generic parameters can contain not only types (like the T in List<T>) but also integers, booleans, and other interesting substances.
This might be familiar from other languages, like C++ and Rust. However, Vale's taking them in a different direction, to enable something called the compile-time spread operator, which will serve as a useful metaprogramming tool for Vale.
This article gives a quick overview of const generics, and then where Vale plans to take them.
Before const generics, we often had a lot of similar classes:
It would be nice if we could pass that 2, 3, 4 in as a generic parameter like we did T!
Enter const generics, which enables just that.
They're used like Vec<2, int>. Much better!
Besides types and integers, we can also have generic parameters that are:
That last one is particularly interesting, as it allows us to implement tuples in Vale:
_ means the field is unnamed, and ..T means "use each of these types".
That .. is known as the spread operator. It can basically be thought of as the "compile-time for-each loop".
(int, bool, str) is syntactic sugar for Tup<RefList[int, bool, str]> which expands to this:
The above works today, in version 0.2. Now we'll show you a sneak peek of where we're heading with this delightful little operator.
We want to be able to use it for function arguments, and in expressions. For example, we could use it to implement a zero-cost variadic println function:
If we called this with println(4, " hello ", true), it's as if the println function contains:
In the previous snippet, the prefix .. (before print) marks the beginning of the "loop", and the postfix .. (after args) specifies what should change in each iteration.
When combined with UFCS, another interesting capability emerges, which we'll call the spread method call. The above snippet can be rewritten as:
It's fascinating how one little symbol can enable such a powerful capability!
Thanks for visiting, hope you enjoyed it!
In the coming weeks, I'll be writing more about our "Fearless FFI" plans which will help us more safely use external C code, so subscribe to our RSS feed twitter, or the r/vale subreddit, and come hang out in the Vale discord!
If you found this interesting, please consider sponsoring us:
With your help, we can write this kind of nonsense more often!
- Evan Ovadia
Vale aims to bring a new way of programming into the world that offers speed, safety, and ease of use.
The world needs something like this! Currently, most programming language work is in:
These are useful, but there is a vast field of possibilities in between, waiting to be explored!
Our aim is to explore that space, discover what it has to offer, and make speed and safety easier than ever before.
In this quest, we've discovered and implemented a lot of new techniques:
These techniques have also opened up some new emergent possibilities, which we hope to implement:
We also gain a lot of inspiration from other languages, and are finding new ways to combine their techniques:
...plus a lot more interesting ideas to explore!
The Vale programming language is a novel combination of ideas from the research world and original innovations. Our goal is to publish our techniques, even the ones that couldn't fit in Vale, so that the world as a whole can benefit from our work here, not just those who use Vale.
Our medium-term goals:
We aim to publish articles biweekly on all of these topics, and create and inspire the next generation of fast, safe, and easy programming languages.
If you want to support our work, please consider sponsoring us on GitHub!
With enough sponsorship, we can: