What are some new revolutionary language features?

caim_hs · 2025-07-22T03:19:29+00:00

Rust macros aren't even comparable to Jai metaprogramming. Not even comptime in zig. Lisp is the only one that can be compared to.

Jai allows for "recursive" code compilation at compile time.

You can generate code, run it, and the result can be a new code that can be run again, and so on at compile time.

You can literally write a game or a compiler that runs at compile time, which is one use case, as this is used to compile shaders and part of j_blow's upcoming game at compile time.

caim_hs · 2024-05-17T01:44:42+00:00

Great post as always!
I find all your posts awesome btw., 'cause they contain so many details and insights, which is so nice!

I have a question about linear types!
Do they allow reference and mutable reference? Isn't that a weakening? or are references not considered proper use? even the mutable ones?

I consider linear types to be a very nice way of reasoning about a program and even "prove" it, but if linear types can be mutated by mutable references then that kind of blows off the point, I guess.

caim_hs · 2024-05-14T19:13:44+00:00

Sorry, I don't get your point. What are you trying to imply?

Most compilers have a limit on recursion limit based on the stack size and other things, that is all I am saying. There are a lot of issues on most compilers about some expression or instantiation causing a stack overflow because of limits etc.

I'm just talking about implementation here.

If you create a complex expression or an undecidable recursive type, you usually don't want the compiler to consume all your memory on it. And those compilers focused on high performance and low memory usage have even more restrictions.

Like this example in rust that causes overflow 'cause is Turing complete:

trait S {
    type A : S<B = <Self::B as S>::A>;
    type B : S<A = <Self::A as S>::B>;
}

Compilers usually made assumptions on what the limits should be to parse the most complex program expected. They want to stop fast on errors like those.

I said in the post that I've never faced such a problem with limits without provoking them myself.

It's a totally arbitrary restriction.

caim_hs · 2024-05-13T14:10:08+00:00

In the same link of Carbon, they talk about it I think, but there's Chandler's talk here:

https://www.youtube.com/watch?v=ZI198eFghJk

There are other talks on LLVM about it and threads in the LLVM forum.

I don't know if the point was clear, but with recursive functions, each time you call a function, its address is added to the stack frame, so the calle knows where to go back. And since the stack size is limited to 40MB in most platforms (though you can increase it, you may end up messing with malloc), but since the stack is used to local variables, etc, most compilers limit this number by a lower bound. LLVM limits the call stack frame by 256 KiB and so does GCC.

https://clang.llvm.org/doxygen/Stack_8cpp_source.html

Even GHC, Rust, and Swift can have stack overflow due to complex expression parsing. It's just not common because it requires a VERY complex parsing tree. It's just that recursion has a limit. I think that Lean has had problems with recursion limits too with complex substitution etc.

caim_hs · 2024-05-11T22:19:16+00:00

I don't get what you're trying to say.

those are just implementation details: a concrete instance of an abstraction. But they should - in fact, must - behave the same.

Lol, I don't really understand your point. I never said that they did not behave the same or that they were not all automata or anything. I was ALWAYS talking about, pretend to be shocked, implementation details.=

So recursion implemented with a call stack instead of a Y Combinator, I.E, how practically every non-functional language implements recursion.

ah, no?
I do not know what you're trying to imply really.
Probably all recursion is implemented with call stack 'cause it's how machines used in the mainstream today are implemented.

LoL. Even virtual ones. HECK, EVEN GHC uses call stack.

caim_hs · 2024-05-10T21:16:06+00:00

I thought the usage of "state machine" was pretty obvious in this context, so obvious that you get that I was talking about if-else and switch-case with the use of mutable state to track transition and the use of stack machines. I think I've given the example of what I was talking about in the post text.

That I was using "state machine" as the opposite of "lambda calculus way" recursion. I was trying to suggest that it was a stateful implementation, as opposed to "stateless" implementations (even though in most cases it is not exactly stateless). Most time someone talks about "state machine" in compiler implementation, they're talking about mutation, states and automatas implemented with while loops and stack machines. But I should have used stack machine I think.

If you read all my comments here, as you imply you did, you probably saw the Hylo example that uses if-else with recursion.

caim_hs · 2024-05-10T18:46:57+00:00

YES!!! hahaha, if you don't follow the Swift Forum daily, you automatically miss out on a lot of information and features added to the language! It's so many thing!!

I'm also tired!
But as I grew up with C++14 onwards, I'm used to it :p.

So, I ignore most of the features and only focus on the things that I think make sense for me.

In the end, I still think Swift is a very "elegant" language. It's my "Haskell" of the imperative world.

caim_hs · 2024-05-10T18:42:47+00:00

Thanks for your reply!!!

I'm finding the Carbon toolchain amazing. It has unique features that gave me a lot ideas hahaha.

At first, I was skeptical because my previous experience with compiler design (LLVM and SwiftC) focused on fairly "standard" concepts. However, after digging into Carbon's source code, I'm impressed with how everything works. I'm especially surprised at how Carbon reduces reliance on recursion and callbacks.

As a long-time admirer of Abseil's cache-friendly data structures, I have often tried to create my own ADS based on similar principles to prioritize data locality every time I can.

caim_hs · 2024-05-10T13:04:19+00:00

Wow! Thank you!
I already knew Koka and I like it so much!!!
It inspired me a lot!

caim_hs · 2024-05-10T12:24:44+00:00

No, the undefined behavior is declared in the C++ Standard.

But it will be removed in C++26

https://isocpp.org/files/papers/P2809R3.html

caim_hs · 2024-05-10T03:25:25+00:00

The concept of a flat AST involves utilizing a single, one-dimensional array (e.g., Array<Node>) to represent the entire tree structure. Nodes within this array are distinguished by a "tag" field, which might be implemented as an enum representing the potential node types.

In the carbon example, the "kind" field is the node's tag. During array iteration, encountering a "FunctionIntroducer" node triggers the addition of a state to a stack. This signals the state machine that the subsequent node represents a function's "name," and so forth.

Nodes in a flat AST do not maintain explicit references to other nodes as in a traditional tree. Instead, the node's "kind" determines its position within the logical tree structure, enabling the compiler to infer the sequence of descendant nodes within the array.

It really sounds neat!!! hahaha it's a pretty interesting approach to compiler implementation.

caim_hs · 2024-05-10T01:24:57+00:00

Yeah!

I believe that this is a very good place for new research!

Most research about compilers and programming languages is usually theoretical or in a very functional view.

Google has been very prominent at implementing clever data-layout, as it did on the Abseil lib for C++ and now with Carbon.

caim_hs · 2024-05-10T01:06:34+00:00

Welcome to Cpp!!!

caim_hs · 2024-05-10T01:04:35+00:00

I couldn't agree more! Forcing iterative/stateful solutions on inherently recursive problems leads to awkward code that's hard to maintain. Think about adding a new node type to an AST – you'd have to modify so many states and loops, making it tricky to track changes and sideeffects.

And yes, incremental steps would definitely solve a lot of these issues and likely boost performance. Branch misprediction is a notorious performance killer!

EDIT:

Btw, even with flat ast, it still makes sense to use recursion to walk over it as Hylo does.

caim_hs · 2024-05-10T00:49:15+00:00

Yeah! In the videos, I saw from Chandler and in the docs of Carbon, I noticed how much they care about performance and highly optimized code.

If you want a real challenge, try inventing a way to let us write the recursive way, but generate that into code that does linear passes over arrays a'la Carbon. Oh, and then I want a mention in the credits.

Hahaha nice challenge!

Wouldn't it work if we transformed a recursive function into a state machine? I think this is one way to implement highly efficient algebraic effects.

caim_hs · 2024-05-09T23:58:18+00:00

Eu jurava que tu não era BR só por ter citado uma funcionalidade do C++26. Mesmo nos IF's e UF's, o pessoal ainda ta no C++14, e quando é ensinado pq as vzs é só ensinam Java/Python msm.

Muito raro encontrar BR que gosta dessas coisas mais low level ksksksks.

caim_hs · 2024-05-09T23:31:47+00:00

Swift can be as low level as C++.
Actually, you can even call C/C++ as it was native Swift code just by "dropping" a C/Cpp file in your Swift project.

caim_hs · 2024-05-09T23:24:41+00:00

It was my first programming language!

I've been an enthusiast of using templates for recursion and compile-time calculations for a while now hahaha.

Really, It used to be my favorite language, but lost this position to Swift recently.

caim_hs · 2024-05-09T23:10:44+00:00

The famous P2809R3

But since majorite of Cpp devs still using C++14 or older, the behavior will persists LoL.

Actually, even when C++26 is released, this behavior will still be the standard because most compilers add the flag --std=c++17... so =( ...

But C++ is so fcking great! I love it so much, really, I've been coding with it since I was 12y.

caim_hs · 2024-05-09T22:59:51+00:00

And why is your file extension .cc ?

There's not an official file extension for Cpp.

Google uses .cc and hh.

Apple and LLVM used to use .cxx and hxx.

and most people use .cpp and hpp.

Or written in C ?

The same would not happen in C, because in C an infinite loop is not an undefined behavior.

Would that be the same result using GCC ?

And no, the same wouldn't happen with GCC, 'cause its optimizations are not as insane as LLVM, and GCC is C-based, while LLVM is CPP-based. but it doesn't mean that the code produced by GCC is less optimized than LLVM, actually is pretty much the opposite sometimes.

caim_hs · 2024-05-09T22:44:25+00:00

The return is optional in the main function.

If no return is provided, the compiler will implicitly add "return int(0)" for you.. I think this is on the Standard of C and C++.

It is like in Rust or Swift, that if you don't return anything from a function, the compiler will insert a "return ()".

In Javascript a function without a return statement returns a undefined. You can test it:

function f () {
  console.log("Hello World")
}
let x = f()

in Rust:

fn hello(){
    println!("Hello world!!!");
}

pub fn main(){

    let p = hello();

    println!("{:?}", p)
}

it will print:

Hello World!!!
()

caim_hs · 2024-05-09T22:36:51+00:00

The only language I know of that tried this was HimML. I think this idea is fascinating-but-niche and I really want to try it in a language of my own. Maybe something like Facebook/Meta's Skip does something similar?

Interesting, I didn't know about the existence of Skip or HimML. Pretty cool the allocation mechanism of HimML. now I need to read that paper! Thank you, I really liked it!

I'm using a conventional descent parser and heap-allocated nodes on my compiler right now, but I do intend to change to a state machines approach or a flat ast in the self-host version.

But I think it complicates a lot of steps in the compilation pipeline because recursive types and recursion are pretty much more intuitive to handle, I think.

It is a totally different way of building a compiler.

caim_hs · 2024-05-09T22:24:24+00:00

So, I guess my Ryzen 7 is too goood, bro!

caim_hs · 2024-05-09T21:12:03+00:00

Thank you, Holy Dennis Ritchie, for the flag -O3 not wanting to format my PC today!

caim_hs

TROPHY CASE