kaleidoscope VS egison

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'.

Look into egison, a "Pattern-Match-Oriented language": https://www.egison.org/

Have a look at Egison. It should be a source of inspiration to anyone doing generalised pattern matching. [_,_/2] ~= [2,1]|[6,3] in particular is even clearer in Egison: $p :: #(p / 2).

I think this is a bad idea. In fact, Egison offers a precedent with a better approach. The offered alternative is strictly more powerful as it allows you to refer to a single subpattern multiple times in a greater pattern, and even marks a computable expression you can use in patterns, allowing code like

Egison language. Research language that does some really neat stuff with pattern matching.

Egison is weird https://www.egison.org -- it takes a single concept (pattern matching) and pushes it as far as it will go.