neat
related_post_gen
neat | related_post_gen | |
---|---|---|
3 | 15 | |
110 | 274 | |
0.9% | - | |
9.4 | 9.9 | |
12 days ago | about 2 months ago | |
D | C++ | |
BSD 3-clause "New" or "Revised" License | MIT License |
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.
neat
-
The Neat Programming Language
It runs on plain C ABI, so you can just define C functions as `extern(C)`, just as you would in D. But you can also use `std.macro.cimport` to import C headers directly. Check out the Dragon demo, https://github.com/Neat-Lang/neat/blob/master/demos/dragon.n... :
macro import std.macro.cimport;
-
Running the "Reflections on Trusting Trust" Compiler
Funny sidestory: The way my compiler ( https://github.com/neat-lang/neat ) used to build is, two years ago there was an initial compiler that was written in D. And every time you checked it out on a new system, there was a file with a list of breaking commits, and it would:
- git clone itself in a subfolder
-
Show HN: C3 – a C alternative that looks like C
Sure, but keep in mind it's pre-pre-alpha and the current released version is kind of outdated (ping me if you actually want to try it):
https://github.com/neat-lang/neat
This is more a D-like than a C-like, but it only breaks C syntax in areas where IMO C straight up made the wrong call, like the inside-out type syntax.
The thing I'm most proud of is the full-powered macro system, which is really more of a compile-time compiler plugin system.
A good example of a macro would be listcomprehensions: https://github.com/Neat-Lang/neat/blob/master/src/neat/macro...
You can tell it's just compiler code that happens to be loaded at project compiletime.
`compiler.$expr xxx` is itself a macro, that parses an expression `xxx` and returns an expression that creates a syntax tree that, when compiled, is equivalent to having written `xxx`. It's effectively the opposite of `eval`. In that expression, `$identifier` is expanded to a variable reference to "identifier".
So `ASTSymbol test = compiler.$expr $where && $test;` is equivalent to `ASTSymbol test = new ASTBinary("&&", where, test)`. (This shows its worth as expressions become more expansive.)
All in all, this lets you write `bool b = [all a == 5 for a in array]`, and it's exactly equivalent to a plain for loop. You can see the exact for loop at line 103 in that file. `({ })` is stolen from gcc; google "statement expression".
related_post_gen
-
Speed up your code: don't pass structs bigger than 16 bytes on AMD64
Looks like the HO means hand optimized, with special datastructures for this benchmark.
see: https://github.com/jinyus/related_post_gen/#user-content-fn-...
-
Benchmarking 20 programming languages on N-queens and matrix multiplication
There is one for data processing here: https://github.com/jinyus/related_post_gen
-
The Neat Programming Language
Is it ready for benchmarking? D currently sits at the top of https://github.com/jinyus/related_post_gen and it would be interesting to see how neat stacks up.
-
Murder is a pixel art ECS game engine in C#
[2] https://github.com/jinyus/related_post_gen#multicore-results
-
Jaq – A jq clone focused on correctness, speed, and simplicity
I think my benchmark[1] would be a great test for this. The jq[2] version takes 50s on my machine.
[1] : https://github.com/jinyus/related_post_gen
[2]: https://github.com/jinyus/related_post_gen/blob/main/jq/rela...
-
Gleam vs Erlang vs Go vs Zig vs Rust for data processing
I added gleam to my data processing benchmark and the performance is less than stellar...so I hope someone here can make suggestions to improve it.
- jinyus/related_post_gen: Data Processing benchmark featuring Rust, Go, Swift, Zig, Julia etc.
-
Ask HN: What's the big deal with Go (Golang)?
Easy concurrency.
ps: I wrote a data processing benchmark[1] and go is currently leading the charts. I ported it to c++ but it's not performing as expected. Take a look if you have the time.
[1]: https://github.com/jinyus/related_post_gen
- Julia leads Rust,Zig,Go and Java in data processing benchmark
- Julia Ranks First in Data Processing Microbenchmark
What are some alternatives?
c4 - C in four functions
uiua - A stack-based array programming language
mescc-tools-seed - A place for public review of the posix port of stage0
pspy - Monitor linux processes without root permissions
archlinux-installer-script - Arch Linux install script. Only performs the minimal steps for booting into arch. 75 lines of script with full progress messages and tutorial.
ivy - ivy, an APL-like calculator
nixpkgs - Nix Packages collection & NixOS
BQN - An APL-like programming language. Self-hosted!
mrustc - Alternative rust compiler (re-implementation)
cognate - A human readable quasi-concatenative programming language
Saxon-HE - Saxon-HE open source repository
git-xargs-tasks - Keep git-xargs changes together