ariadne VS kaleidoscope

To complement, Nushell's error rendering is done with miette (whose name is a reference to this cute meme AFAIK). There is also another notable Rust error rendering lib: ariadne. So you can get the same beautiful error rendering in your own projects :D

Hey gophers, I'm looking for something like this https://github.com/zesterer/ariadne for my compiler project, can u suggest any pkgs?

I'm looking for something similar to this rust crate https://github.com/zesterer/ariadne, but I can't find anything. I'm just starting to play with go and I really don't know where to look.

Because of that, we made a new modern error message system for Otterkit, which should still display useful information to experienced developers, while also being easy to read and understand for new developers. This new format was inspired by Rust's error messages, and both the Errata NuGet package and Ariadne Rust crate.

i really like chumsky for parsing (and it works very well with it's sister crate ariadne)

I've also been looking into https://github.com/zesterer/ariadne as I'm building a static compiler using Jinja and want to return nicer messages when there is a parsing issue.

If you’d like to see some examples of great error messages written by a language with a parser combinator, I recommend you check out tao, which is parsed via chumsky, and provides rust-like error messages with the help of ariadne! I have been fiddling with writing my own language for a while now, and after trying out the alternatives, I found Chumsky to be great to work with, and can not recommend it enough. There are also great examples that you can find in the repo as well!

The major thing I'm going to do is support nicer error messages like in https://github.com/zesterer/ariadne. Then add support for language server (LSP) and shoe them interactively on editors.

Comparing the haskell and cpp implementations of the LLVM tutorial lead me to believe it might be faster to learn haskell and implement the compiler in haskell than to implement it in cpp.

I think for writing compilers Haskell deserves to make the list. It is really excellent at creating DSLs. https://www.stephendiehl.com/llvm/

I'm no expert, but you might be interested in: https://llvm.org/docs/tutorial/

There's also a Haskell version if you'd prefer: https://www.stephendiehl.com/llvm/

Idk how to do this in python as I'm not really good with it, but in C, to make your compiler a JIT, you would `mmap` a region as writeable, write the machine code to it that you already know how to generate, `mprotect` it as PROT_EXEC instead of PROC_WRITE, cast the pointer to the region to a function pointer, and then call it. These functions may be available in the python sys package but I don't really know.

I've implemented a "JIT" that takes machine code as hex and does this. Warning: it's complete garbage with no error checking but is a good proof of concept. https://gist.github.com/martinjacobd/3ee56f3c7b7ce621034ec3e...

This is amazing. I tried following Stephen Diehl's JIT compiler in LLVM tutorial[0] a few years ago but it was already outdated (the llvm-hs library changed quite a bit), and subsequent web searches didn't turn up much.

For those interested in tutorials like this, I'd also recommend a very literate Haskell compiler for the PCF language to C[1], which is essentially lambda calculus with some primitives.

[0] https://www.stephendiehl.com/llvm/

[1] https://github.com/jozefg/pcf/

I'm currently working with llvm-hs-pure and am struggling to properly emit code for a module. I basically followed https://www.stephendiehl.com/llvm/#chapter-3-code-generation and have types like:

http://www.stephendiehl.com/llvm/ Implementing a JIT Compiled Language with Haskell and LLVM Nice tutorial. Requires knowledge of monads, applicatives, transformers. Deep enough and more or less 'real world'.